{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "background_save": true,
     "base_uri": "https://localhost:8080/",
     "height": 794
    },
    "executionInfo": {
     "elapsed": 6585,
     "status": "ok",
     "timestamp": 1748251232444,
     "user": {
      "displayName": "Yusuf Khan",
      "userId": "12411237408315334872"
     },
     "user_tz": -330
    },
    "id": "rWBJgxM0047i",
    "outputId": "bf013e4a-2b45-49ca-b332-a3f72121787c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting mediapipe==0.10.5\n",
      "  Downloading mediapipe-0.10.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (9.6 kB)\n",
      "Requirement already satisfied: absl-py in /usr/local/lib/python3.11/dist-packages (from mediapipe==0.10.5) (1.4.0)\n",
      "Requirement already satisfied: attrs>=19.1.0 in /usr/local/lib/python3.11/dist-packages (from mediapipe==0.10.5) (25.3.0)\n",
      "Requirement already satisfied: flatbuffers>=2.0 in /usr/local/lib/python3.11/dist-packages (from mediapipe==0.10.5) (25.2.10)\n",
      "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (from mediapipe==0.10.5) (3.10.0)\n",
      "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from mediapipe==0.10.5) (2.0.2)\n",
      "Requirement already satisfied: opencv-contrib-python in /usr/local/lib/python3.11/dist-packages (from mediapipe==0.10.5) (4.11.0.86)\n",
      "Collecting protobuf<4,>=3.11 (from mediapipe==0.10.5)\n",
      "  Downloading protobuf-3.20.3-py2.py3-none-any.whl.metadata (720 bytes)\n",
      "Collecting sounddevice>=0.4.4 (from mediapipe==0.10.5)\n",
      "  Downloading sounddevice-0.5.2-py3-none-any.whl.metadata (1.6 kB)\n",
      "Requirement already satisfied: CFFI>=1.0 in /usr/local/lib/python3.11/dist-packages (from sounddevice>=0.4.4->mediapipe==0.10.5) (1.17.1)\n",
      "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->mediapipe==0.10.5) (1.3.2)\n",
      "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib->mediapipe==0.10.5) (0.12.1)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib->mediapipe==0.10.5) (4.58.0)\n",
      "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->mediapipe==0.10.5) (1.4.8)\n",
      "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib->mediapipe==0.10.5) (24.2)\n",
      "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib->mediapipe==0.10.5) (11.2.1)\n",
      "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->mediapipe==0.10.5) (3.2.3)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib->mediapipe==0.10.5) (2.9.0.post0)\n",
      "Requirement already satisfied: pycparser in /usr/local/lib/python3.11/dist-packages (from CFFI>=1.0->sounddevice>=0.4.4->mediapipe==0.10.5) (2.22)\n",
      "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib->mediapipe==0.10.5) (1.17.0)\n",
      "Downloading mediapipe-0.10.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (33.5 MB)\n",
      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m33.5/33.5 MB\u001b[0m \u001b[31m17.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hDownloading protobuf-3.20.3-py2.py3-none-any.whl (162 kB)\n",
      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m162.1/162.1 kB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hDownloading sounddevice-0.5.2-py3-none-any.whl (32 kB)\n",
      "Installing collected packages: protobuf, sounddevice, mediapipe\n",
      "  Attempting uninstall: protobuf\n",
      "    Found existing installation: protobuf 5.29.4\n",
      "    Uninstalling protobuf-5.29.4:\n",
      "      Successfully uninstalled protobuf-5.29.4\n",
      "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
      "tensorflow-metadata 1.17.1 requires protobuf<6.0.0,>=4.25.2; python_version >= \"3.11\", but you have protobuf 3.20.3 which is incompatible.\n",
      "ydf 0.11.0 requires protobuf<6.0.0,>=5.29.1, but you have protobuf 3.20.3 which is incompatible.\n",
      "grpcio-status 1.71.0 requires protobuf<6.0dev,>=5.26.1, but you have protobuf 3.20.3 which is incompatible.\u001b[0m\u001b[31m\n",
      "\u001b[0mSuccessfully installed mediapipe-0.10.5 protobuf-3.20.3 sounddevice-0.5.2\n"
     ]
    },
    {
     "data": {
      "application/vnd.colab-display-data+json": {
       "id": "b65aa161d07741118b3ccc61ac0b3730",
       "pip_warning": {
        "packages": [
         "google"
        ]
       }
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "!pip install mediapipe==0.10.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5283,
     "status": "ok",
     "timestamp": 1746003214594,
     "user": {
      "displayName": "Yusuf Khan",
      "userId": "12411237408315334872"
     },
     "user_tz": -330
    },
    "id": "TwYf0m0s5qKr",
    "outputId": "fe83419c-d2cb-42e0-bd2f-8e8e61a99e72"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Mount Google Drive\n",
    "from google.colab import drive\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "executionInfo": {
     "elapsed": 108392,
     "status": "ok",
     "timestamp": 1748320252892,
     "user": {
      "displayName": "Yusuf Khan",
      "userId": "12411237408315334872"
     },
     "user_tz": -330
    },
    "id": "4DzFZsnFT8l2",
    "outputId": "a67bb915-5200-4994-a6d3-fd9df9175529"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "     <input type=\"file\" id=\"files-ad7ecc47-eb83-44f5-bcc9-beb13c4163a8\" name=\"files[]\" multiple disabled\n",
       "        style=\"border:none\" />\n",
       "     <output id=\"result-ad7ecc47-eb83-44f5-bcc9-beb13c4163a8\">\n",
       "      Upload widget is only available when the cell has been executed in the\n",
       "      current browser session. Please rerun this cell to enable.\n",
       "      </output>\n",
       "      <script>// Copyright 2017 Google LLC\n",
       "//\n",
       "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
       "// you may not use this file except in compliance with the License.\n",
       "// You may obtain a copy of the License at\n",
       "//\n",
       "//      http://www.apache.org/licenses/LICENSE-2.0\n",
       "//\n",
       "// Unless required by applicable law or agreed to in writing, software\n",
       "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
       "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
       "// See the License for the specific language governing permissions and\n",
       "// limitations under the License.\n",
       "\n",
       "/**\n",
       " * @fileoverview Helpers for google.colab Python module.\n",
       " */\n",
       "(function(scope) {\n",
       "function span(text, styleAttributes = {}) {\n",
       "  const element = document.createElement('span');\n",
       "  element.textContent = text;\n",
       "  for (const key of Object.keys(styleAttributes)) {\n",
       "    element.style[key] = styleAttributes[key];\n",
       "  }\n",
       "  return element;\n",
       "}\n",
       "\n",
       "// Max number of bytes which will be uploaded at a time.\n",
       "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
       "\n",
       "function _uploadFiles(inputId, outputId) {\n",
       "  const steps = uploadFilesStep(inputId, outputId);\n",
       "  const outputElement = document.getElementById(outputId);\n",
       "  // Cache steps on the outputElement to make it available for the next call\n",
       "  // to uploadFilesContinue from Python.\n",
       "  outputElement.steps = steps;\n",
       "\n",
       "  return _uploadFilesContinue(outputId);\n",
       "}\n",
       "\n",
       "// This is roughly an async generator (not supported in the browser yet),\n",
       "// where there are multiple asynchronous steps and the Python side is going\n",
       "// to poll for completion of each step.\n",
       "// This uses a Promise to block the python side on completion of each step,\n",
       "// then passes the result of the previous step as the input to the next step.\n",
       "function _uploadFilesContinue(outputId) {\n",
       "  const outputElement = document.getElementById(outputId);\n",
       "  const steps = outputElement.steps;\n",
       "\n",
       "  const next = steps.next(outputElement.lastPromiseValue);\n",
       "  return Promise.resolve(next.value.promise).then((value) => {\n",
       "    // Cache the last promise value to make it available to the next\n",
       "    // step of the generator.\n",
       "    outputElement.lastPromiseValue = value;\n",
       "    return next.value.response;\n",
       "  });\n",
       "}\n",
       "\n",
       "/**\n",
       " * Generator function which is called between each async step of the upload\n",
       " * process.\n",
       " * @param {string} inputId Element ID of the input file picker element.\n",
       " * @param {string} outputId Element ID of the output display.\n",
       " * @return {!Iterable<!Object>} Iterable of next steps.\n",
       " */\n",
       "function* uploadFilesStep(inputId, outputId) {\n",
       "  const inputElement = document.getElementById(inputId);\n",
       "  inputElement.disabled = false;\n",
       "\n",
       "  const outputElement = document.getElementById(outputId);\n",
       "  outputElement.innerHTML = '';\n",
       "\n",
       "  const pickedPromise = new Promise((resolve) => {\n",
       "    inputElement.addEventListener('change', (e) => {\n",
       "      resolve(e.target.files);\n",
       "    });\n",
       "  });\n",
       "\n",
       "  const cancel = document.createElement('button');\n",
       "  inputElement.parentElement.appendChild(cancel);\n",
       "  cancel.textContent = 'Cancel upload';\n",
       "  const cancelPromise = new Promise((resolve) => {\n",
       "    cancel.onclick = () => {\n",
       "      resolve(null);\n",
       "    };\n",
       "  });\n",
       "\n",
       "  // Wait for the user to pick the files.\n",
       "  const files = yield {\n",
       "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
       "    response: {\n",
       "      action: 'starting',\n",
       "    }\n",
       "  };\n",
       "\n",
       "  cancel.remove();\n",
       "\n",
       "  // Disable the input element since further picks are not allowed.\n",
       "  inputElement.disabled = true;\n",
       "\n",
       "  if (!files) {\n",
       "    return {\n",
       "      response: {\n",
       "        action: 'complete',\n",
       "      }\n",
       "    };\n",
       "  }\n",
       "\n",
       "  for (const file of files) {\n",
       "    const li = document.createElement('li');\n",
       "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
       "    li.append(span(\n",
       "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
       "        `last modified: ${\n",
       "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
       "                                    'n/a'} - `));\n",
       "    const percent = span('0% done');\n",
       "    li.appendChild(percent);\n",
       "\n",
       "    outputElement.appendChild(li);\n",
       "\n",
       "    const fileDataPromise = new Promise((resolve) => {\n",
       "      const reader = new FileReader();\n",
       "      reader.onload = (e) => {\n",
       "        resolve(e.target.result);\n",
       "      };\n",
       "      reader.readAsArrayBuffer(file);\n",
       "    });\n",
       "    // Wait for the data to be ready.\n",
       "    let fileData = yield {\n",
       "      promise: fileDataPromise,\n",
       "      response: {\n",
       "        action: 'continue',\n",
       "      }\n",
       "    };\n",
       "\n",
       "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
       "    let position = 0;\n",
       "    do {\n",
       "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
       "      const chunk = new Uint8Array(fileData, position, length);\n",
       "      position += length;\n",
       "\n",
       "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
       "      yield {\n",
       "        response: {\n",
       "          action: 'append',\n",
       "          file: file.name,\n",
       "          data: base64,\n",
       "        },\n",
       "      };\n",
       "\n",
       "      let percentDone = fileData.byteLength === 0 ?\n",
       "          100 :\n",
       "          Math.round((position / fileData.byteLength) * 100);\n",
       "      percent.textContent = `${percentDone}% done`;\n",
       "\n",
       "    } while (position < fileData.byteLength);\n",
       "  }\n",
       "\n",
       "  // All done.\n",
       "  yield {\n",
       "    response: {\n",
       "      action: 'complete',\n",
       "    }\n",
       "  };\n",
       "}\n",
       "\n",
       "scope.google = scope.google || {};\n",
       "scope.google.colab = scope.google.colab || {};\n",
       "scope.google.colab._files = {\n",
       "  _uploadFiles,\n",
       "  _uploadFilesContinue,\n",
       "};\n",
       "})(self);\n",
       "</script> "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving ground_truth.txt to ground_truth.txt\n",
      "Video FPS: 29.548271\n",
      "Extracted 1801 frames.\n",
      "Computed 137 BP windows.\n",
      "Window 000: Systolic = 131.64, Diastolic = 71.89\n",
      "Window 001: Systolic = 127.38, Diastolic = 81.54\n",
      "Window 002: Systolic = 123.09, Diastolic = 73.27\n",
      "Window 003: Systolic = 140.72, Diastolic = 76.27\n",
      "Window 004: Systolic = 117.07, Diastolic = 73.42\n",
      "Window 005: Systolic = 143.83, Diastolic = 77.74\n",
      "Window 006: Systolic = 135.84, Diastolic = 73.84\n",
      "Window 007: Systolic = 133.54, Diastolic = 73.31\n",
      "Window 008: Systolic = 140.95, Diastolic = 70.22\n",
      "Window 009: Systolic = 121.86, Diastolic = 69.88\n",
      "Window 010: Systolic = 139.71, Diastolic = 71.61\n",
      "Window 011: Systolic = 129.19, Diastolic = 65.03\n",
      "Window 012: Systolic = 132.20, Diastolic = 76.46\n",
      "Window 013: Systolic = 119.72, Diastolic = 66.67\n",
      "Window 014: Systolic = 137.48, Diastolic = 78.87\n",
      "Window 015: Systolic = 120.83, Diastolic = 72.08\n",
      "Window 016: Systolic = 133.64, Diastolic = 71.11\n",
      "Window 017: Systolic = 110.81, Diastolic = 78.13\n",
      "Window 018: Systolic = 121.70, Diastolic = 71.76\n",
      "Window 019: Systolic = 139.12, Diastolic = 74.09\n",
      "Window 020: Systolic = 107.53, Diastolic = 72.88\n",
      "Window 021: Systolic = 148.68, Diastolic = 83.91\n",
      "Window 022: Systolic = 123.74, Diastolic = 74.58\n",
      "Window 023: Systolic = 136.98, Diastolic = 76.29\n",
      "Window 024: Systolic = 130.25, Diastolic = 73.26\n",
      "Window 025: Systolic = 129.11, Diastolic = 75.07\n",
      "Window 026: Systolic = 132.65, Diastolic = 78.02\n",
      "Window 027: Systolic = 136.61, Diastolic = 70.81\n",
      "Window 028: Systolic = 137.52, Diastolic = 72.32\n",
      "Window 029: Systolic = 130.66, Diastolic = 71.42\n",
      "Window 030: Systolic = 131.45, Diastolic = 73.72\n",
      "Window 031: Systolic = 129.82, Diastolic = 70.33\n",
      "Window 032: Systolic = 138.62, Diastolic = 69.07\n",
      "Window 033: Systolic = 128.69, Diastolic = 72.56\n",
      "Window 034: Systolic = 131.11, Diastolic = 72.34\n",
      "Window 035: Systolic = 132.26, Diastolic = 74.12\n",
      "Window 036: Systolic = 122.19, Diastolic = 76.39\n",
      "Window 037: Systolic = 137.64, Diastolic = 75.86\n",
      "Window 038: Systolic = 122.46, Diastolic = 72.64\n",
      "Window 039: Systolic = 130.52, Diastolic = 76.85\n",
      "Window 040: Systolic = 132.57, Diastolic = 75.82\n",
      "Window 041: Systolic = 136.89, Diastolic = 81.04\n",
      "Window 042: Systolic = 120.86, Diastolic = 75.99\n",
      "Window 043: Systolic = 140.10, Diastolic = 77.36\n",
      "Window 044: Systolic = 134.77, Diastolic = 73.11\n",
      "Window 045: Systolic = 145.66, Diastolic = 78.60\n",
      "Window 046: Systolic = 134.47, Diastolic = 71.16\n",
      "Window 047: Systolic = 135.83, Diastolic = 68.08\n",
      "Window 048: Systolic = 139.72, Diastolic = 72.22\n",
      "Window 049: Systolic = 135.29, Diastolic = 71.25\n",
      "Window 050: Systolic = 134.34, Diastolic = 74.12\n",
      "Window 051: Systolic = 125.95, Diastolic = 74.97\n",
      "Window 052: Systolic = 127.39, Diastolic = 76.40\n",
      "Window 053: Systolic = 130.77, Diastolic = 77.36\n",
      "Window 054: Systolic = 119.55, Diastolic = 79.49\n",
      "Window 055: Systolic = 124.66, Diastolic = 75.81\n",
      "Window 056: Systolic = 135.58, Diastolic = 79.14\n",
      "Window 057: Systolic = 144.59, Diastolic = 78.29\n",
      "Window 058: Systolic = 134.88, Diastolic = 78.15\n",
      "Window 059: Systolic = 143.18, Diastolic = 73.98\n",
      "Window 060: Systolic = 134.09, Diastolic = 72.01\n",
      "Window 061: Systolic = 145.46, Diastolic = 76.42\n",
      "Window 062: Systolic = 138.06, Diastolic = 70.69\n",
      "Window 063: Systolic = 143.09, Diastolic = 72.87\n",
      "Window 064: Systolic = 135.68, Diastolic = 75.04\n",
      "Window 065: Systolic = 137.05, Diastolic = 76.34\n",
      "Window 066: Systolic = 129.39, Diastolic = 74.62\n",
      "Window 067: Systolic = 125.48, Diastolic = 75.03\n",
      "Window 068: Systolic = 125.92, Diastolic = 76.13\n",
      "Window 069: Systolic = 129.85, Diastolic = 74.11\n",
      "Window 070: Systolic = 130.29, Diastolic = 79.08\n",
      "Window 071: Systolic = 124.15, Diastolic = 73.21\n",
      "Window 072: Systolic = 138.61, Diastolic = 74.86\n",
      "Window 073: Systolic = 139.00, Diastolic = 78.50\n",
      "Window 074: Systolic = 143.47, Diastolic = 73.17\n",
      "Window 075: Systolic = 140.31, Diastolic = 73.94\n",
      "Window 076: Systolic = 131.51, Diastolic = 75.22\n",
      "Window 077: Systolic = 141.51, Diastolic = 72.36\n",
      "Window 078: Systolic = 133.73, Diastolic = 72.52\n",
      "Window 079: Systolic = 133.92, Diastolic = 70.52\n",
      "Window 080: Systolic = 133.68, Diastolic = 72.30\n",
      "Window 081: Systolic = 131.87, Diastolic = 73.21\n",
      "Window 082: Systolic = 131.59, Diastolic = 71.30\n",
      "Window 083: Systolic = 129.99, Diastolic = 76.17\n",
      "Window 084: Systolic = 127.63, Diastolic = 79.59\n",
      "Window 085: Systolic = 130.19, Diastolic = 72.72\n",
      "Window 086: Systolic = 139.67, Diastolic = 79.46\n",
      "Window 087: Systolic = 123.13, Diastolic = 72.36\n",
      "Window 088: Systolic = 141.91, Diastolic = 73.37\n",
      "Window 089: Systolic = 126.30, Diastolic = 72.58\n",
      "Window 090: Systolic = 144.50, Diastolic = 74.39\n",
      "Window 091: Systolic = 127.16, Diastolic = 71.68\n",
      "Window 092: Systolic = 131.72, Diastolic = 75.86\n",
      "Window 093: Systolic = 135.04, Diastolic = 73.12\n",
      "Window 094: Systolic = 132.70, Diastolic = 75.97\n",
      "Window 095: Systolic = 128.70, Diastolic = 73.14\n",
      "Window 096: Systolic = 137.62, Diastolic = 72.97\n",
      "Window 097: Systolic = 129.79, Diastolic = 75.56\n",
      "Window 098: Systolic = 129.81, Diastolic = 70.48\n",
      "Window 099: Systolic = 144.60, Diastolic = 76.99\n",
      "Window 100: Systolic = 124.99, Diastolic = 72.37\n",
      "Window 101: Systolic = 138.21, Diastolic = 69.90\n",
      "Window 102: Systolic = 133.11, Diastolic = 71.76\n",
      "Window 103: Systolic = 127.57, Diastolic = 73.56\n",
      "Window 104: Systolic = 129.88, Diastolic = 71.77\n",
      "Window 105: Systolic = 126.83, Diastolic = 72.28\n",
      "Window 106: Systolic = 140.12, Diastolic = 78.36\n",
      "Window 107: Systolic = 116.99, Diastolic = 75.56\n",
      "Window 108: Systolic = 130.60, Diastolic = 80.51\n",
      "Window 109: Systolic = 131.62, Diastolic = 74.21\n",
      "Window 110: Systolic = 137.86, Diastolic = 81.08\n",
      "Window 111: Systolic = 125.92, Diastolic = 75.82\n",
      "Window 112: Systolic = 141.17, Diastolic = 76.28\n",
      "Window 113: Systolic = 134.00, Diastolic = 75.40\n",
      "Window 114: Systolic = 136.19, Diastolic = 72.73\n",
      "Window 115: Systolic = 139.69, Diastolic = 75.37\n",
      "Window 116: Systolic = 127.36, Diastolic = 75.29\n",
      "Window 117: Systolic = 141.34, Diastolic = 74.40\n",
      "Window 118: Systolic = 130.57, Diastolic = 72.96\n",
      "Window 119: Systolic = 128.98, Diastolic = 76.97\n",
      "Window 120: Systolic = 137.19, Diastolic = 77.55\n",
      "Window 121: Systolic = 127.29, Diastolic = 75.05\n",
      "Window 122: Systolic = 138.81, Diastolic = 79.13\n",
      "Window 123: Systolic = 118.07, Diastolic = 77.06\n",
      "Window 124: Systolic = 143.63, Diastolic = 80.42\n",
      "Window 125: Systolic = 121.17, Diastolic = 76.02\n",
      "Window 126: Systolic = 140.66, Diastolic = 80.89\n",
      "Window 127: Systolic = 129.54, Diastolic = 75.81\n",
      "Window 128: Systolic = 143.49, Diastolic = 77.62\n",
      "Window 129: Systolic = 130.01, Diastolic = 72.34\n",
      "Window 130: Systolic = 138.61, Diastolic = 73.84\n",
      "Window 131: Systolic = 137.70, Diastolic = 75.23\n",
      "Window 132: Systolic = 134.22, Diastolic = 73.85\n",
      "Window 133: Systolic = 140.35, Diastolic = 76.22\n",
      "Window 134: Systolic = 124.36, Diastolic = 71.29\n",
      "Window 135: Systolic = 133.81, Diastolic = 75.75\n",
      "Window 136: Systolic = 133.93, Diastolic = 76.68\n",
      "\n",
      "Average Predicted → Systolic: 132.63, Diastolic: 74.62\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABNYAAAHWCAYAAAC7TQQYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd4HNXZxc9s1656lyxZkqvcOwaDsakGUxMIMaGThN6SQBJSICQQSgKhQ4BQAibkowcwxcYF4957kWX13ttKW+f7Y+benV1tmVG39P6ehyfxltnR7OzMve897zmCKIoiCIIgCIIgCIIgCIIgCILQhG6wd4AgCIIgCIIgCIIgCIIgTkSosEYQBEEQBEEQBEEQBEEQPYAKawRBEARBEARBEARBEATRA6iwRhAEQRAEQRAEQRAEQRA9gAprBEEQBEEQBEEQBEEQBNEDqLBGEARBEARBEARBEARBED2ACmsEQRAEQRAEQRAEQRAE0QOosEYQBEEQBEEQBEEQBEEQPYAKawRBEARBEARBEARBEATRA6iwRhAEQRDDnNzcXFx//fX832vXroUgCFi7du2g7VMggft4IrF48WIsXrx4sHeDIwgC/vSnP0V8XU1NDS6//HIkJSVBEAQ8/fTT/b5vPaW4uBiCIODNN98c7F1RzdatW2EymVBSUjLYuzLsOHjwIAwGA/bv3z/Yu0IQBEEQVFgjCIIgiP7kzTffhCAI/D+LxYIJEybgjjvuQE1NzWDvniZWrFihqmDTnyiPpSAIsNlsmDx5Mh5++GHY7Xa/115//fV+r42NjcWMGTPw5JNPwuFwRPys4uJi3HDDDRg7diwsFgvS09Nx+umn48EHH+yvP29A+cUvfoGvv/4a999/P95++22cd955g71LmvjTn/7k9/1arVZMnjwZf/jDH9Da2spfp/U3WFtbi9/+9reYNm0aoqOjYbFYMG7cONxwww34/vvvVe/f73//e1x55ZXIycnhjy1evNhvX6KiojB9+nQ8/fTT8Hq9vTsgYcjNzYUgCLjzzju7PccK7R988IHm7VZWVuJPf/oTdu/e3e25I0eO4Be/+AUWLFgAi8UCQRBQXFwcdDvKY2IwGJCYmIg5c+bg7rvvxsGDB7u9fvLkybjgggvwwAMPaN5ngiAIguhrDIO9AwRBEAQxEvjzn/+MvLw8dHV14fvvv8dLL72EFStWYP/+/bBarQO6L6effjo6OzthMpk0vW/FihV44YUXBr24ds455+Daa68FALS3t2P9+vX44x//iD179uD999/3e63ZbMZrr70GAGhubsaHH36Ie++9F9u2bcN7770X8jOOHTuGefPmISoqCjfeeCNyc3NRVVWFnTt34vHHH8dDDz3EX/vNN9/0w1/Z/6xevRqXXHIJ7r333sHelYjk5OSgs7MTRqOx23MvvfQSoqOj0d7ejm+++QaPPPIIVq9ejQ0bNkAQBP46Nb/BrVu34oILLkBbWxuWLVuGW265BWazGUVFRfjkk0/w5ptvYt26dTj99NPD7u/u3buxatUqbNy4sdtzWVlZePTRRwEA9fX1ePfdd/GLX/wCdXV1eOSRR3pzmCLy6quv4v7770dmZmafbK+yshIPPfQQcnNzMXPmTL/nNm3ahGeffRaTJ0/GpEmTghbflLDftSiKaGlpwZ49e/DWW2/hxRdfxOOPP45f/vKXfq+/5ZZbsHTpUhQWFmLs2LF98vcQBEEQRE+gwhpBEARBDADnn38+5s6dCwD42c9+hqSkJDz11FP49NNPceWVVwZ9T0dHB2w2W5/vi06ng8Vi6fPtDhQTJkzA1Vdfzf99yy23wOl04qOPPkJXV5ff32YwGPxee9ttt2H+/Pn473//i6eeeipkgeEf//gH2tvbsXv3bj/FESApmpRoLVAOFWpraxEfHx/xdf11HmqBKc2CcfnllyM5ORmAdC5cdtll+Oijj7B582accsop/HWRfoNNTU249NJLYTAYsHv3buTn5/t9zsMPP4z33nsPUVFREff3jTfewOjRo3HyySd3ey4uLq7b+Zufn4/nnnsOf/7zn6HX6yMfkB4wZcoUHDlyBI899hieffbZfvkMJRdffDGam5sRExODv//97xELa4G/awB47LHHcNFFF+FXv/oV8vPzsXTpUv7c2WefjYSEBLz11lv485//3B9/AkEQBEGoglpBCYIgCGIQOPPMMwEARUVFAKS2xejoaBQWFmLp0qWIiYnBVVddBQDwer14+umnMWXKFFgsFqSlpeHmm29GU1OT3zZFUcTDDz+MrKwsWK1WnHHGGThw4EC3zw7lsbZlyxYsXboUCQkJsNlsmD59Op555hm+fy+88AIA/7YtRl/vo1bS09N5G1k4dDod90ML1ZYGAIWFhcjKyupWVAOA1NRUv38H81grKSnBxRdfDJvNhtTUVN52GXjcFy9ejKlTp+LgwYM444wzYLVaMWrUKDzxxBN+23M6nXjggQcwZ84cxMXFwWazYeHChVizZk3YvzcYrDVSFEW88MILft8le27dunW47bbbkJqaiqysLP7eF198EVOmTIHZbEZmZiZuv/12NDc3dzseU6dOxd69e7Fo0SJYrVaMGzeOtxquW7cO8+fPR1RUFCZOnIhVq1ZF3GctHmuBvy21r3v55ZdRVVWFp59+ultRDZDO+yuvvBLz5s2LuA+ffPIJzjzzTL/fSCgsFgvmzZuHtra2bkXbd955B3PmzEFUVBQSExOxbNkylJWV+b2moKAAl112GdLT02GxWJCVlYVly5ahpaXF73W5ubm49tpr8eqrr6KysjLiflVUVODGG29EWloazGYzpkyZgtdff50/v3btWn4sbrjhBn4ese8oMTERMTExET8nHElJSXjvvfdgMBi6qfmMRiMWL16MTz/9tFefQRAEQRC9hQprBEEQBDEIFBYWApAmjgy3240lS5YgNTUVf//733HZZZcBAG6++Wbcd999OPXUU/HMM8/ghhtuwPLly7FkyRK4XC7+/gceeAB//OMfMWPGDPztb3/DmDFjcO6556KjoyPi/qxcuRKnn346Dh48iLvvvhtPPvkkzjjjDHz++ed8H8455xwAwNtvv83/YwzEPjK6urpQX1+P+vp6lJSU4N1338Vbb72Fn/zkJxELa0DwYx9ITk4OysrKsHr1atX7xejo6MCZZ56JVatW4a677sLvf/97bNy4Eb/5zW+Cvr6pqQnnnXce93/Lz8/Hb37zG3z55Zf8Na2trXjttdewePFiPP744/jTn/6Euro6LFmyJKISKJDTTz+df3fnnHNOt+8SkJR9Bw8exAMPPIDf/va3ACRPs9tvvx2ZmZl48skncdlll+Gf//wnzj33XL/vmP1NF154IebPn48nnngCZrMZy5Ytw3//+18sW7YMS5cuxWOPPYaOjg5cfvnlaGtr0/Q3hEPN9xvsdZ999hmioqLwwx/+sFefX1FRgdLSUsyePVv1e1jhUKkgfOSRR3Dttddi/PjxeOqpp3DPPffg22+/xemnn86LmU6nE0uWLMHmzZtx55134oUXXsBNN92E48ePdyt4ApLvm9vtxmOPPRZ2f2pqanDyySdj1apVuOOOO/DMM89g3Lhx+OlPf8pDLiZNmsSVYjfddBM/jyK1yWpl9OjRWLRoETZv3uznnQcAc+bMwf79+7s9ThAEQRADikgQBEEQRL/xxhtviADEVatWiXV1dWJZWZn43nvviUlJSWJUVJRYXl4uiqIoXnfddSIA8be//a3f+9evXy8CEJcvX+73+FdffeX3eG1trWgymcQLLrhA9Hq9/HW/+93vRADiddddxx9bs2aNCEBcs2aNKIqi6Ha7xby8PDEnJ0dsamry+xzltm6//XYx2NChP/YxFACC/nfppZeKXV1dfq+97rrrRJvNJtbV1Yl1dXXisWPHxL/+9a+iIAji9OnTw37O/v37xaioKBGAOHPmTPHuu+8WP/nkE7Gjo6PbaxctWiQuWrSI//vJJ58UAYiffPIJf6yzs1PMz8/3O+7svQDEf//73/wxh8Mhpqeni5dddhl/zO12iw6Hw+9zm5qaxLS0NPHGG2/sdowefPDBsH8fe93tt9/u9xg7X0877TTR7Xbzx9l3d+6554oej4c//vzzz4sAxNdff73b3/Tuu+/yxw4fPiwCEHU6nbh582b++Ndffy0CEN94442w+1pUVNTtdQ8++KAIQDxy5IhYV1cnFhUVif/85z9Fs9kspqWl8e9K7W8wISFBnDlzZrfPbm1t5edQXV2d2N7eHnZfV61aJQIQP/vss27PLVq0SMzPz+fbOnz4sHjfffeJAMQLLriAv664uFjU6/XiI4884vf+ffv2iQaDgT++a9cuEYD4/vvvh92nnJwcvv0bbrhBtFgsYmVlpSiKvuuBchs//elPxYyMDLG+vt5vO8uWLRPj4uJEu90uiqIobtu2TdX397e//U0EIBYVFQV9Pti5qOTuu+8WAYh79uzxe/zdd98VAYhbtmwJ+/kEQRAE0Z+QYo0gCIIgBoCzzz4bKSkpyM7OxrJlyxAdHY2PP/4Yo0aN8nvdrbfe6vfv999/H3FxcTjnnHO4Squ+vh5z5sxBdHQ0bwVctWoVnE4n7rzzTr/2s3vuuSfivu3atQtFRUW45557unluqWllG4h9VHLJJZdg5cqVWLlyJT799FPcf//9+Oqrr/CTn/wEoij6vbajowMpKSlISUnBuHHj8Lvf/Q6nnHIKPv7447CfMWXKFOzevRtXX301iouL8cwzz+DSSy9FWloaXn311bDv/eqrrzBq1ChcfPHF/DGLxYKf//znQV8fHR3t5y1lMplw0kkn4fjx4/wxvV7Pvdy8Xi8aGxvhdrsxd+5c7Ny5M+z+9ISf//znfl5f7Lu75557oNPp/F4XGxuLL774otvftGzZMv7viRMnIj4+HpMmTcL8+fP54+z/K/9WrUycOBEpKSnIy8vDzTffjHHjxuGLL77oFgoS6TfY2tqK6Ojobtu/5ppr+DmUkpISUnnIaGhoAAAkJCQEff7w4cN8W/n5+fjb3/6Giy++2K/N9aOPPoLX68UVV1zh95tKT0/H+PHj+W8qLi4OAPD11193S8UNxR/+8IewqjVRFPHhhx/ioosugiiKfp+/ZMkStLS09Ms5Fw72vQQqG9kxrq+vH9D9IQiCIAglFF5AEARBEAPACy+8gAkTJsBgMCAtLQ0TJ070K1AAktG+0s8KkPyTWlpauvl6MZgnU0lJCQBg/Pjxfs+npKSEnOAzWEvc1KlT1f9BA7yPSrKysnD22Wfzf1988cVISkrCvffei88//xwXXXQRf85iseCzzz4DICWE5uXldTvGoZgwYQLefvtteDweHDx4EJ9//jmeeOIJ3HTTTcjLy/PbByUlJSUYO3Zst6LkuHHjQv49ga9NSEjA3r17/R5766238OSTT+Lw4cN+rZd5eXmq/h4tBG6TfXcTJ070e9xkMmHMmDH8eUawvykuLg7Z2dndHgPQzYtPCx9++CFiY2NhNBqRlZUVMiEy0m8wJiYG7e3t3d735z//GXfccQcA8HZoNQQWeRm5ubl49dVX4fV6UVhYiEceeQR1dXV+4QwFBQUQRbHbb4XB0lHz8vLwy1/+Ek899RSWL1+OhQsX4uKLL8bVV1/Nj20gY8aMwTXXXINXXnmFt/kqqaurQ3NzM1555RW88sorQbcR6AXX37DvJdCzjR1jNQsABEEQBNFfUGGNIAiCIAaAk046iScShsJsNncrtnm9XqSmpmL58uVB35OSktJn+9hThsI+nnXWWQCA7777zq+wptfrQxbA1KLX6zFt2jRMmzYNp5xyCs444wwsX76819tVbj8YysLMO++8g+uvvx6XXnop7rvvPqSmpkKv1+PRRx/lhdG+RE3yZThC/U1q/latnH766TwVNByRfoP5+fnYs2cPXC4XL1wBwPTp0zXtD/NsC1UstNlsfufOqaeeitmzZ+N3v/sdT+v0er0QBAFffvll0GOmVNY9+eSTuP766/Hpp5/im2++wV133YVHH30UmzdvDllE/v3vf4+3334bjz/+OC699FK/57xeLwDg6quvxnXXXRf0/VqPSW/Zv38/9Hp9t4IvO8Zqvn+CIAiC6C+osEYQBEEQQ5ixY8di1apVOPXUU8MWO1h6ZUFBAcaMGcMfr6uri6gGYgqf/fv3hy0WhVKFDMQ+RsLtdgNAUMVRX8IKM1VVVSFfk5OTg4MHD0IURb9jduzYsR5/7gcffIAxY8bgo48+8tvmgw8+2ONtaoF9d0eOHPH77pxOJ4qKivqsyDiYXHjhhdi8eTM+/vhjXHHFFT3eDksUjZRKypg+fTquvvpq/POf/8S9996L0aNHY+zYsRBFEXl5eZgwYULEbbDC7x/+8Ads3LgRp556Kl5++WU8/PDDQV8/duxY/pnK1lxAKoTHxMTA4/FE/F4HQilWWlqKdevW4ZRTTummWCsqKoJOp1N1jAiCIAiivyCPNYIgCIIYwlxxxRXweDz4y1/+0u05t9vNk//OPvtsGI1GPPfcc37qH5bgF47Zs2cjLy8PTz/9dLckQeW2bDYbAHR7zUDsYyRYu+eMGTN6vS0AWL9+fbekSwBYsWIFgO4tkUqWLFmCiooK/O9//+OPdXV1RfRmCwdTLSmP25YtW7Bp06Yeb1MLZ599NkwmE5599lm/ffjXv/6FlpYWXHDBBQOyH/3JrbfeirS0NPziF7/A0aNHuz2vVlU3atQoZGdnY/v27ao/+9e//jVcLheeeuopAMAPf/hD6PV6PPTQQ90+VxRF7uPW2trKi8qMadOmQafTweFwhP3MP/zhD3C5XHjiiSf8Htfr9bjsssvw4YcfYv/+/d3eV1dXx/9/qGtCX9HY2Igrr7wSHo8Hv//977s9v2PHDkyZMiVk2ytBEARBDASkWCMIgiCIIcyiRYtw880349FHH8Xu3btx7rnnwmg0oqCgAO+//z6eeeYZXH755UhJScG9996LRx99FBdeeCGWLl2KXbt24csvv4zYJqXT6fDSSy/hoosuwsyZM3HDDTcgIyMDhw8fxoEDB/D1118DAObMmQMAuOuuu7BkyRLo9XosW7ZsQPZRydGjR/HOO+8AAOx2OzZv3oy33noL48aNwzXXXNPDI+3P448/jh07duCHP/whb3vbuXMn/v3vfyMxMTFs4MLNN9+M559/HldeeSXuvvtuZGRkYPny5dxDqycqnwsvvBAfffQRfvCDH+CCCy5AUVERXn75ZUyePLnfVXqApGK6//778dBDD+G8887DxRdfjCNHjuDFF1/EvHnz/MIXTlQSExPx8ccf46KLLsKMGTOwbNkyzJs3D0ajEWVlZXj//fcBAKNHj464rUsuuQQff/xxN9ViKCZPnoylS5fitddewx//+EeMHTsWDz/8MO6//34UFxfj0ksvRUxMDIqKivDxxx/jpptuwr333ovVq1fjjjvuwI9+9CNMmDABbrcbb7/9Ni+OhYOp1t56661uzz322GNYs2YN5s+fj5///OeYPHkyGhsbsXPnTqxatQqNjY18G/Hx8Xj55ZcRExMDm82G+fPnIy8vDy0tLXjuuecAABs2bAAAPP/884iPj0d8fDz3rWOw37UoimhtbcWePXvw/vvvo729HU899RTOO+88v9e7XC6sW7cOt912W8TjSxAEQRD9ysCGkBIEQRDEyOKNN94QAYjbtm0L+7rrrrtOtNlsIZ9/5ZVXxDlz5ohRUVFiTEyMOG3aNPHXv/61WFlZyV/j8XjEhx56SMzIyBCjoqLExYsXi/v37xdzcnLE6667jr9uzZo1IgBxzZo1fp/x/fffi+ecc44YExMj2mw2cfr06eJzzz3Hn3e73eKdd94ppqSkiIIgiIHDiL7cx1AA8PtPr9eLWVlZ4k033STW1NRoOqbh2LBhg3j77beLU6dOFePi4kSj0SiOHj1avP7668XCwkK/1y5atEhctGiR32PHjx8XL7jgAjEqKkpMSUkRf/WrX4kffvihCEDcvHmz33unTJnS7fOvu+46MScnh//b6/WKf/3rX8WcnBzRbDaLs2bNEj///PNur2PH6MEHH4z4NwIQb7/9dr/HIp2vzz//vJifny8ajUYxLS1NvPXWW8WmpqZuxyPY35STkyNecMEFqvYjkKKiIhGA+MYbb/DHHnzwQRGAWFdXF/a9an+DjKqqKvG+++4TJ0+eLEZFRYlms1kcM2aMeO2114rfffedqm3s3LlTBCCuX7/e7/FQx0YURXHt2rXdvrsPP/xQPO2000SbzSbabDYxPz9fvP3228UjR46IoiidZzfeeKM4duxY0WKxiImJieIZZ5whrlq1ym/boY59QUGBqNfrRQDi+++/7/dcTU2NePvtt4vZ2dmi0WgU09PTxbPOOkt85ZVX/F736aefipMnTxYNBoPfd8S+s2D/BTtn2X86nU6Mj48XZ82aJd59993igQMHgh6vL7/8UgQgFhQUBH2eIAiCIAYKQRR74RZLEARBEARBqOLpp5/GL37xC5SXl2PUqFGDvTtEP3PWWWchMzMTb7/99mDvyrDk0ksvhSAI+Pjjjwd7VwiCIIgRDhXWCIIgCIIg+pjOzk6/IIeuri7MmjULHo8nqH8XMfzYsmULFi5ciIKCAh7+QPQNhw4dwrRp07B7925MnTp1sHeHIAiCGOFQYY0gCIIgCKKPOf/88zF69GjMnDkTLS0teOedd3DgwAEsX74cP/nJTwZ79wiCIAiCIIg+gsILCIIgCIIg+pglS5bgtddew/Lly+HxeDB58mS89957+PGPfzzYu0YQBEEQBEH0IaRYIwiCIAiCIAiCIAiCIIgeoBvsHSAIgiAIgiAIgiAIgiCIExEqrBEEQRAEQRAEQRAEQRBEDyCPNQBerxeVlZWIiYmBIAiDvTsEQRAEQRAEQRAEQRDEICGKItra2pCZmQmdLrwmjQprACorK5GdnT3Yu0EQBEEQBEEQBEEQBEEMEcrKypCVlRX2NVRYAxATEwNAOmCxsbGDvDe9x+Vy4ZtvvsG5554Lo9E42LtDDHPofCMGCjrXiIGEzjdioKBzjRhI6HwjBgo614iBor/OtdbWVmRnZ/N6UTiosAbw9s/Y2NhhU1izWq2IjY2lixjR79D5RgwUdK4RAwmdb8RAQecaMZDQ+UYMFHSuEQNFf59rauzCKLyAIAiCIAiCIAiCIAiCIHoAFdYIgiAIgiAIgiAIgiAIogdQYY0gCIIgCIIgCIIgCIIgegAV1giCIAiCIAiCIAiCIAiiB1BhjSAIgiAIgiAIgiAIgiB6ABXWCIIgCIIgCIIgCIIgCKIHUGGNIAiCIAiCIAiCIAiCIHoAFdYIgiAIgiAIgiAIgiAIogdQYY0gCIIgCIIgCIIgCIIgegAV1giCIAiCIAiCIAiCIAiiB1BhjSAIgiAIgiAIgiAIgiB6ABXWCIIgCIIgCIIgCIIgCKIHUGGNIAiCIAiCIAiCIAiCIHoAFdYIgug36tocuP6Nrfj6QPVg7wpBEARBEARBEARB9DmGwd4BgiCGL2uP1GLtkTo4XF4smZI+2LtDEARBEARBEARBEH0KKdYIgug3OhxuAECT3TnIe0IQBEEQBEEQBEEQfQ8V1giC6Dc6nB4AVFgjCIIgCIIgCIIghidUWCMIot/o5IU1F0RRHOS9IQiCIAiCIAiCIIi+hQprBEH0Gx1OqRXU6fai0+UZ5L0hCIIgCIIgCIIgiL6FCmsEQfQbTLEGSKo1giAIgiAIgiAIghhOUGGNIIh+o0NZWOsgnzWCIAiCIAiCIAhieEGFNYIg+o1OuRUUAJpJsUYQBEEQBEEQBEEMM6iwRhBEv9HhULaCkmKNIAiCIAiCIAiCGF5QYY0giH7DrggsaKbCGkEQBEEQBEEQBDHMoMIaQRD9ht3hawWl8AKCIAiCIAiCIAhiuEGFNYIg+g27k1pBiZGBy+MlVSZBEARBEARBjECosEYQRL9hp/ACYoRw45vbMP+v36KqpXOwd4UYAFweLzYVNsDt8Q72rhAEQRAEQRCDDBXWCILoNzoUirXGDlLzEMMTl8eLzccb4HB7saOkabB3hxgA3txQjCtf3YyX1hYO9q4QBEEQBEEQgwwV1giC6BfcHi+cbp+ag9rkiOFKcX0HXB4RAHC0pn2Q94YYCLYVNwIAVh2uHeQ9IQiCIAiCIAYbKqwRBNEvKBNBAQovIIYvymLasdq2QdwTYqA4Vit95/srWtDWRdc2giAIgiCIkQwV1giC6Bc6nYGFNVKsEcOTIzW+YloBKdYGjCPVbfj1B3tQ3+4Y0M91uD0oabQDADxeEduLqf2XIAaD/RUtqG7pGuzdGFK4PF7c/9FefL63crB3hSAIYkRBhTWCIPqFDofb799tXW4y+iaGJUerfYW1ovoOvxZoov/4x8qj+L/t5XhjQ9GAfm5xvR0er8j/vfl4w4B+PkEQQGVzJy5+/ntc/8bWwd6VIcXGwgb8Z2sZnvzm6GDvCkEQxIiCCmsEQfQLdlmxlhxt4o81d1LLFDH8OKpo/3R7RZQ0dAzi3owc9pY3AwD2V7QO6OcWBLT7UmGNIAaewrp2eEWgoLbdr9A90imT1bQ1raTkIwiCGEiosEYMKEX1HXj1u+NwuD2RX0yc0LDCWozFiFiLAQAFGBDDjy6XB8X1UiFtVHwUAAowGAjq2hyolFvADlYNcGFN/n4Xjk8GAOyraEEr+awRxIBS0yq1gHu8IhoGuB18KFPe1AlAGoMFdg4QBEEQ/QcV1ogB5W9fH8YjKw7hgx3lg70rRD9jd0oDOqtJjwSbpFqjAANiuMFUE/FWI04ZmwSgu6KJ6HuYWg2Qimy1bQOnzmDBBaePT0FOkhVeEdgup4QSBDEwKBVZVeSzxilvsvP/X9dGBUdi5PJ/28vw8rrCQflsURTJFmQEQoU1YkBhK4xbjtMkZLjDFGtWkx7xVrmw1kGKNWJ4wdRLE1JjMCEt2u8xov/YU97i9+8DlQOnWmOFtXFp0Tg5TyqmbqZ72qCz5kgtZv35G3y6u2Kwd4UYAJSFtWpqe+SUyYo1AKilwhoxQvF6Rfzh4/147MvDgxJwctPbO7DgsW+pU2eEQYU1YkBhFxha3R/+sBYEq8mABKsRANBMijVimMESQSekR2N8WgwAUqwNBEyxZtAJAICDGgtroijioc8O4Mlvjmh6n9vjxfF6qbA2PjWaqxS1+qztK2+h+2Af84+VR9Fkd+GBTw+gkRZxhj3Kwhr5ifmoIMUaQaCtyw2nHJg2kIp2QGpPX3ekDvXtTuwNWAQkhjdUWCMGlJZOqdhS2dKFiubOCK8mTmQ6XZJizWbWI4Ep1mjlhhhmsETQiWkxGJ8qKdaK6jvgogTcfkMUReyTB6vnTkkDAByo1DZ4LahtxxsbivHc6mOaBt0ljXa4PCKsJj0y46Iwf0wiAGC/Bp+1FrsLP35lE658dTNqqSDQJ+wua+YTmJZOF/72tbaCKXHiwTogAGoFZXQ6Pahv942z6ga4oEAQQwXlfKNhgBdaalq7eFGPwqxGFlRYIwYMURTR0um7uNFq/fCmwyEV1qKMBsTLijXyWCOGGywRdHxaDEbFR8Fm0sPloWTQ/qSiuRMNHU4YdAIun5MFQHsr6I6SJv7/91eoL8qxNt9xqdHQ6QRkxEUhV/ZZ21ak7p72+b5K2J0euDwiNlGiaJ/w9qYSAMDUUbEAgPe2lWr6XokTD2VRuoYKawCAima737/rKNSBGKE0d/rmG43tA1tYK230/Q5LGuxhXkkMN6iwRgwYbCLBUE5siOFHpxxeoFSskdcAMZzocLhR1igpbyekxUAQBIyTVWuUDNp/MGVSfkYMZmUnAJAGr1qSOXcq7j9aWjWOyYXUcSnR/DGt7aAf7fR5gJE3W+9p7HDis72VAIC/XDIVF8/IhCgCD/7vAERRjPBu4kTE6xX9/MNIsSah9FcDgNpWKqwRIxOlYm2grQH8CmuNVFgbSVBhjRgwlKsHALCtmAprw5kOObwgyqTnHmvUCkoMJwpkE/uUGDMS5eRb7rNGhbV+Y4/srzY9Kx4JNhMy4ywAgEMaVGs7S333n30aCmsFiuACxslj1AcYFNV3+C0qafVmI7rz/vYyON1eTBsVh5nZ8fjd0kmwmvTYUdKEj3dRkMFwpNHuhNvrK5qSx5pEeUBhjRRrxEileRBbQcsUxbRSUqyNKKiwRgwYLXIboNkgnXZHqls1KQyIEwuWCmozGXypoNQKSgwjjrLgAkWRhfmsHaUAg36DFcKmj4oDAEzOlP5XbTtos92Jwjpfq+7eihbVyiaWCDo+NYY/Nl9OBj1Q2YKWzvDXuI93lgMAZo+Oh06QCm2DkVg2XPB6RbyzRWoDvebkHAiCgPQ4C+44cxwA4NEvD6ONxhlDlpKGDryzuUSzJyUrpAlSdgmqW7tInQigXJ7Q5yXbAFB4ATFyUYalNQxwgdlfsdZB16YRBBXWiAGjWfZXy060YnSi5Emzq7R5cHeK6DfsTpYKSq2gxPCEBRdMSPMVWdj/P0aKtX7B6/UFF0zPigcATMmUfLXUFtbYfWdUfBT0OgF1bQ5Uq1C8eLyiorDmK6amx1mQl2yL6LPm9Yr4UG4DvW5BLqbIBcEtRaRa6ynrjtahrLETcVFGXDQjkz/+09PykJdsQ12bA8+tPjaIe0iE4y+fH8IfPtmPlQdrNL2PtTiOkQtIdqcHrV3uPt+/Ew2mWJuVHQ+ACmvEyEW5kD/QraBKX7Uul9evbZ0Y3lBhjRgwmGItPsqIuTmSL84OCjAYtjDFmtVkQIKNwguI4ceRmu6FNeaxdry+nZJB+4Gihg60OdywGHVcKcgKawer1BXWWBvo/DGJ/LtT47NW0dQJh9sLk0GH7ESr33O+dtDQRbKtxY2oaO5EjNmAJVPScbKcKErtoD3n7c2SWu1Hc7IQZdLzx80GPR64cDIA4PXvi3hBtKe4PF788r+78dbG4l5th/CntFFSjh6v0/b9sEJ4bpINcVHS+ILaQYHyJmlCP0seY9e3O+DxklqGCA9bCB9OtAyBVlCmqKUAg5EDFdaIAYN5rMVbjZibK00oyGdt+BJMsdbU4SRJNDFsYD5qysLaqPgoWHkyKA2m+pq9sr/alMw4GPTSEGaK3BJaUNMGh9sTcRussDZ7dAJvJ1Xjs1Ygt/eOSbZBrxP8nuNFsjDqsw93SG2gS6dlwGLUK0IPaIGpJ5Q12rHmSC0A4KqTc7o9f0Z+Ks7MT4XbK+LPnx/s1b1nU2EDPtpVgce+PEwF8z6EKTkqmrUVxVgRLTXWggzZY5ECDHyKtZlZ8RAEwCsOvFqHCM624kZe+BxK7C5rxvQ/fYPHvzo82LvSpwyWYq3d4eaFPDa+KKaU+BEDFdaIAYN5z8RGGTE3V1pN213W3GeDVK9XxOd7K2nVcojgU6z5Cmtur4h2x/BbGSNGHi12F1dNKD3WdDpfMmhBDfms9TV7yqQC2DR5wAoAmXEWxEUZ4faKEUMjPF4Ru+VW0Dk5CZiWJW1nb4WawprcBqoopDJOGcN81lq5OltJp9ODFfuqAACXzckCAMzNTSSftV7wzpYSiCKwcHwy95QK5IELJ8Ok1+G7o3Wa2w2VMDVkp8uD/SrOFSIyXS4P90GqaO6M8Gp/auRW0LRYM9JipcJazQj/Ddmdvgn96CQrkuRAHWoHHXwKatpwxT834WdvbR/sXenG5uMNcHtFrD5UO9i70qcMViooU6slWI180Y8CDEYOVFgjNCGKIv5ve1mPBpbNvBXUhHEp0YiLMqLT5cFBDUlu4fhoVwXueHcXHl1xqE+2R/QOu0MOLzAbEGXS89CKZmoHJYYBLJwgM86CGIvR7zlmbF/Qy/Yzojv75HvPjGxfYU0QBIXPWvh705HqNnQ4PYg2GzAhLQbTWWGtvDmioimYvxojNdaCMSk2iKLU8hnI1weq0eH0IDsxilshxFqMmDqKfNZ6QpfLg//bVgYAuPaU3JCvy0224WcL8wAAf/niILpckRWNwTikaDPeRhYWfYKy4FOpsbBWKy9qpMVakB5LijVAalUHgFiLAXFRRiRHmwFQMuhQ4FB1G0QROFzdprmI3N8wo/3CunY43cNHjasMEmp3uDVf+0VRRGGddksPdjxHJ1qRmyRZRpQ0UmFtpDCohbXvvvsOF110ETIzMyEIAj755JOQr73lllsgCAKefvppv8cbGxtx1VVXITY2FvHx8fjpT3+K9naazPQXe8tb8OsP9uK+D/Zqfm+LHF4QbzVCpxMwR55cbC/pm3bQ747WAYBf2hsxeHTIraDM94a3g1KAATEM4Img6d3VS+NlBRsV1voWt8fLC2csuIChNsCAtYHOyI6DXidgYnoMTHodmu0u3kYVioIwhTUgvM/ah3Ia6A9nZUGnaCNl79lUSIU1LXyxtwpNdhdGxUfhzPzUsK+9/YxxSI+1oKyxE69+d7xHn6dcANxaRBYWfYHS0LuiqVNTq25NGyusmZEut4KqCSAZzpTJbYZZCdJkPiVGKqzVjvDjMhSoUNxbNh6rH8Q96Q5TWLm94rBqWQyca2hVrX19oBpnPbkOf//miKb3seMpBfVJSurSYXRcifAMamGto6MDM2bMwAsvvBD2dR9//DE2b96MzMzMbs9dddVVOHDgAFauXInPP/8c3333HW666ab+2uURD7voVrVoX3HhijWrpO5g7aDb+2D1VxRFbJInM7VtNIgYCnTKraA2kwGA73unAANiOMASQScGaQtkraHUCtq3HK1pR5fLixizAXlJ/q1/LGFTbWFt9mjp/mM26JGfETnAQBRFHJO/z3EaC2vVLV3YIE+mLpudFfAeCjDoCf+WQwt+Mn90N7+7QGxmA+5fmg8AeGHtMc3jly6XB4UKc/3tJY3wkiF8r1EWfDoVbaFq8LWCWnhhbaTbgLCFgayEKABAaox0XEixNvhUNPsUS0NtEaVUoaY6Uj18xiyB1xOthTU2ltgaJuk7GErFWo6sWCseQq2gHq+IG9/chp//ezt5XvcDg1pYO//88/Hwww/jBz/4QcjXVFRU4M4778Ty5cthNPq32xw6dAhfffUVXnvtNcyfPx+nnXYannvuObz33nuorKzs790fkbCBS0unC26N8lh2kWMJTnNzpAnF9pKmXv+4j9d38LaC+nYnDXqHAB2K8ALAp1hrJsUaMQQpa7Tj/GfW43971N07WCJoML8t1gp6vK5D83WSCA0LLpg6Ks5P9QX4FGuHqlrDpuDtkv3VWGEN8Pm17a1oDvm+qpYudDg9MOgE5CQF9/M6OU+6px2savW7zn2yuwJeEZiXm4DRSf5posxnrbjB3qMFq5HI3vJm7ClrhlEv4MfzslW95+IZmZiZHY8ulxffHNDmtXa0pg1eUfLMiTLq0Wx3kRq1D6gN8P5S2yLn9nhR3969sDbSW0FZYY0lFjPF2nDyWHv484M48+9rg/pYDmWUaugNhfVDpqDh9nj91HRHh8lioNvjRVuXNAdJi5V+B1qTQWvl4v2xmnZN31ewwlpLp2vInLO7y5qw+nAtVh6sGVbXhqGCYbB3IBxerxfXXHMN7rvvPkyZMqXb85s2bUJ8fDzmzp3LHzv77LOh0+mwZcuWkAU7h8MBh8N3MrW2SlVpl8sFl2tonPi9gf0N/fG3VMpSc1EE6ts6uTmqGthEI9qkg8vlwuQ0K4x6AXVtDhTWtiIn0RphC6HZUOAz3fR4RdS2dCBJ9pdQv3+SGXl+kNYuIjTBzjePV0SXSyooGHUiXC4X4qKky019W9ew+J0RA09/Xts+31OBQ1WteOKrwzhvUjIEIbwKhg1AxyZFddufVJsBUUYdOl1eFNa0YkxK8EKMWtweL3aUNmNuTkJEdc5wZneZpDabmhnT7Zhnx5thMepgd3pwrLol6DFv7HCiqF5SXU/NiObbmJIhKdD2lDb5bVd5vh2WW1BzkqwQRA9cQfxaEqL0GJNsw/H6Dmw6VoezJ6VCFEV8sF3yArt0Rka3/Y7SS0XBfRWt2FBQh0tmZGg/MCOMf28sBgCcNyUNcWad6uvBaWMTsbusGbtLG/GTeaNUf94++byblBEDUQQ2HW/EpsI6jEmyaN73UPTnta2/6XR6YDHqIl4zA6lu9ldxlNa3Y2Jq5HFgdWsXRBEw6ATEGAUkW6WxRXVL5wl5/PoK1m6WEWuCy+VConxcalu6j7lO1PPtgx3laO50YUdJPRaOSx7s3VFNuUIVVtPqwNGq4PeontLl8sDlERFj0TatL2/qhFuxEHWosqXPz4nBONcaFCrN3CQralodqGuxa9qHmlap4NjmcKOsoZ2nD0eC/Q4z40wwCiJSok2oa3eisLbFL3RpsPhmfzX//yX1bUiI0g/i3vQt/XWuadnekC6sPf744zAYDLjrrruCPl9dXY3UVH9vDYPBgMTERFRXVwd9DwA8+uijeOihh7o9/s0338Bq7XlxZ6ixcuXKPt/m7qM6MKHjp1+uQrqGw1XdqAcg4MDOrWgvkB4bFaVHcbuANz5bh5NSer6C84livwDgoy+/xSiN96znDuhQ2CrgtzM8mv4uQkJ5vnV5AHZ5Wb96FUx6oLVe+o627TmI5Mb9g7KPxPCgP65tW4ql87O8qRMv/d+XyA1TX29zAY0dBggQcWzn9yjd0/01ySY9ylwC/vvVd5iR1LvV6Y+LdVhbpcOSLC+WZo9cBdz3B6V7iLu2ECtWHOv2fJpZjxKXgHe//A6zk7sf8/2NAgA90qJEbFzrO4eaOwDAgN2ljfj8ixUIrF2uXLkSayql90Z72rBixYqQ+5ih1+E4dHhvzU44i7woaweO1RlgFEToK/dixYru/qQpXunc+/C7PTBW7FJ1LEYqHS7g013SeTDWW44VK8pVv9fZJH2HG49UYsWKMtXv+6pI+n4s9npIAmwd/rfxABLq92nc+8j0x7WtP2noAh7do8fMJBFXj9N2bdpxzH/ctmrTDriKI18rS9oAwIBogxdfffUlOlzSv5vsLnz6+QoYR2gs24Fi6XdRXXgQK5oOoKJeOt8Pl1SF/J2cSOeb3Q00d0rjyjUbtqHt6NBQfUVCFIHSBum7iTeJaHYKeO2z73Baet/sv8cLPLVfj4Yu4I+zPLAZI7+HcbRFOkcYu4tqw97fesNAnms1nQBgQJRehKu1AYAO32/fA2PlbtXbOFYhfWcA8O7nazApIfL35RWBEvm7PrZ7C5oOA9GCHnUQ8Om3G1EWZFwy0Hy62/d3fbF2Eyp7OT4divT1uWa3q2/lHbKFtR07duCZZ57Bzp07Na+CReL+++/HL3/5S/7v1tZWZGdn49xzz0VsbGyfftZg4HK5sHLlSpxzzjnd2md7y1sVW4GGZgDAtLmnYF5uQvg3KPjdjm8BeLD07MVcHrtPfxSvfV8Md/xoLF3aXZWoBlEU8fC+dQCcMOgEuL0iJs48CaeP17aa9cDu1RDhhi13OpbOzYr8BgJA8POtrs0BbF0HQQAuufB8CIKAwysLsLGmCCmjcrB06aRB3mviRKQ/r22r3t8LVEkLMg3RY3Cb7MkUjE3HG4DtO5CdaMWlFy0M+pq1nftQtrsKsdkTsXTxmB7vV0O7A7/eth6AF1sbzXjyxtNhNg6fFUa1OFwe/GrLagAirrtoMUbFR3V7zWb3QZRsK4cpbSyWLpnQ7flDKwuAI0U4bdIoLF06lT/u9njxzMHV6HJ7MWX+IuQlS6syyvNt44qjQEkFTps+DkvPGhdyP8V91djwf3tRK8Zh6dJT8OcvDgMoxblTM3DZxdODvsd6tA6r396FSnc0li49TduBGWG8vqEYLvEo8tNjcNsVJ2saH87vcOKVx9aiplPAwjPP6ZbmG4q3X9sKoBlLF0xHaqwZX72xA5WuKJx//ul9Nj7tz2tbf/KfbWVw7TqEUocFS5cu0vTeD97aAdQ1ID7KiOZOF+Izx2Dp+RMjvm/lwVpg/27kpMZj6dL5EEURD+3+Fg63F7MWLMboXnQ/nMj8ac8aAC5ccvZpyE+PQVJRI94q2A6vydbtunIinm/7KlqAbVsAAKMnTMbSU3IGeY/U0WR3wrl5LQDgylPG4KV1RWizZmLp0hl9sv33tpWjfMtBAED65JOwUMPcp317OXDwIKZmxmJ/ZSsanAIWn30urKa+Kw8Mxrm2o6QJ2L0NKXFWTBmfgp0NpUjPGYel54xXvY2/7l8HQFK+JeROwtJTcyO+p6qlC57N38GgE3DlJefBoNdhbec+FO2uQuLo3o0F+4KSRjuqN33P/50+Rt3fdaLQX+ca62xUw5AtrK1fvx61tbUYPXo0f8zj8eBXv/oVnn76aRQXFyM9PR21tbV+73O73WhsbER6enrIbZvNZpjN3dsEjUbjCXODUUN//D3MMBYAWh1e1dt3ebzokM3sk2Oj+PtOykvCa98XY2dpS4/3tbCuHXXtTpgMOsweHY/NxxvRYHdr2l6Xy4OWTqkf/1idfVidB73lpbWF2FvejOeunAWDPvRSsPJ8c3qltl+rUQ+TSWoXTpKNdFu6PHR8iV7RH9e2+naf1HvF/ho8cNGUkOf78XqpRWBiemzI/ZiQHgegCsfre3c9+feWQjjckhKkye7C14fqcdmckVf431/VDrdXRKLNhJzkmKAFjWlZCfjPtnIcrmkPesx3y+EEc3OT/J43GqV2zJ2lzThU04EJGfF+7zMajSisk1YsJ4T5zgHg1PGSiv5wTRuau7z4Yp9UrL18bnbI9508NgU6QRr01tvdyIjrXjQkgKYOJ/6zTVLeXHtKLr+3qCU93ojsxCiUNXbiUI0dp6poJfN6RRyulvzUpmUnYnSiFQadgOpWB2ra3dzPqq840cahh6qltqe6NgcEnT7sGCGQunZpnDBrdDzWHKlDdZtD1d/eIHsVpcdZ+OvT4ywoabCjwe7B2LQT5/j1FR0ONw+GykmJgdFoREaCtEBQ3+4MeVxPpPOtvMXnkdV6Ao0ja9ule0dytBlnT07HS+uKsKWoEXq9oZtXqFa6XB48v7aQ/7u0qUvTcalokeZ0s3MSUNXShYYOJ0qaHJie1ff3oIE819qckgorwWpCijz3aNIwL/R6RdQrPNkKVY7jquQCzKiEKERZpDpDXkoMgCqUN2v7bvqDdQX+QQw1baGvDScyfX2uadnWkBVMX3PNNdi7dy92797N/8vMzMR9992Hr7/+GgBwyimnoLm5GTt27ODvW716NbxeL+bPnz9Yuz5s8XpFv8RNLQkrLZ2+SatylXhOjqR4K6ht77GpPUvYmT06HtlyzLhWQ0ZlmtThavWV6ZHAi2uO4cv91TisIS3ILhdRrWZf7T5eDi8IjMAmiKGA8tpW3+7A5uOhk6CO1EgT7WCJoAyWDNobM+CWThfe3iSlH54kG+OzNMSRBkvsnJ4VF1IlxAIMDla2djMbdnu82FMmbYPdd5RMz4oHAP4aJaIocrN6FkwRipQYM8alRkMUgSe+OozGDidSYsxh/YBiLEbuvULpoBJ2pxtbixrx2vrjuOPdnTj9iTWY9ZeVKG6wI8ZswKWzuqfEq2GG/D3vLmtW9frypk60O9wwGXQYk2JDlEmPqfJ3ta0PEs1PdA7I3oNesXsYQSTYOG2WHCSiNFEPhzIRlJEeywIMRmYACDPHj4syIlYeY7PwgjaHm6e0n8iUyP6YgHYj+sFEmdY6PSseNpMeTXYXDvXBXOOtjcV+gofjimOkBqXR/kTZX3ooJYO22F14Y0ORn2eaGth8Mt5qQqLsBa7lnGm0O/1CkI7WqAurKVEcTwbr0CppHPxk0G8PScE9TJVfqTIwhlDPoBbW2tvbedEMAIqKirB7926UlpYiKSkJU6dO9fvPaDQiPT0dEydKUvFJkybhvPPOw89//nNs3boVGzZswB133IFly5YhM7Nngy4iNI12J1we34VGS4GEJYLGWgx+5ttJ0WZu4LmjpKlH+8UmIiePSUKqnP5SqzF2vVqRJnWkum3IJPYMNm1dLrQ5JCVfa5d680a7nAhqM/la1hKs0mAvMAKb0M4nuyrwyBcHKf22D2GTPFbA+t+eipCvPcoTQaNDvoYng9b3PBn07U3FaHO4MSEtGi/8ZDZMeh32lEmJiCMNX2EtPuRrJqbHQK8T0NDh9JtsAMDh6jZ0ujyIsRgwLqX79zY9SyqW7AuSDFrf7kRLpws6AaoMp08eI51D7++Q1FWXzsyMqOQ5eUwSAGBz4cgu1ryw5hiW/OM7TH3wa1zxz014+ItD+HxvFZ8A5iZZ8cBFk3vcqjQzOx4AVP+GDlZJk98JadEwyt8hu0aM9MKay+PF4SrfJFxLUcvp9vKJ7qzR8QCAimZ14za2EOpXWJONxWs0jv2GC+VysFhWgk9pFGM2wGyQztnhkP5X3OArTDSdUIU1ab9HJUTBqNfx6wcTBfSUlk4XXpTVaqfI948ijYW1MkUhaIK8UDiUkkH/9f1xPPTZQby6vkjT+9g8I95qRHK0VFhr7FD/Gwj8vRyrVZcMyo6nUsnMimwlDeq/m06nBw9+uh9vbihCV5CgpJ7Q0unC1iLpnnXVfKkbsFLlNZdQz6AW1rZv345Zs2Zh1qxZAIBf/vKXmDVrFh544AHV21i+fDny8/Nx1llnYenSpTjttNPwyiuv9Ncuj2iqA6LMtSnWfKsHgczLYYNU7YU1URS5suSUMUlIlSW/WldOqxWDsSa7a1gMQvoC5SCVRVergSnWokykWOtrPF4Rf/hkP15dL7UTEL2ny+VBq3x+/+y0PADAl/ur4XB3H9CIosgHnhPDJAhnJUTBYtTB6fbyooAW7E43Xt9QDAC4/YxxSIkx44LpUmLkvzeNPNXa3vJmAMCMrNCpWhajHmPlwhdT0jB2lkr3l5nZ8UHbb1hhbX9Fq99KNQAcq5NWq0cnWmFR4W/HimQMNa27vLBWNHIVaw3tDvzt6yM4UtMGryipkM6dnIb7lkzE2z89CXseOBdr7zsDP5qb3ePPmMEKa/L5FAlWWJuc4fPfnZcrjVm2jvDrb0FNO5yKRQMtk7R6WYFi0AmYkhnHH1MziayRx2epMT5LF1ZYq2oZmRNFpopiXRsAIAgCX2yuaz/xj0tp44mpWKuQVUFZsi/ogrGSenljLwtrr3xXiJZOFyakReMX50ieosfreqhYS1Io1lSqswYCdv2t0KisapbnnAlWExJt0m9Ay5yVzSHHpthg0Alod7hVXVvY8cxRFNZyk6QxSU2ruusbAHywowxvbSrBnz47iIVPrMFr64/3WnW67mgd3F4R41OjccpYabxBirW+Z1ALa4sXL4Yoit3+e/PNN4O+vri4GPfcc4/fY4mJiXj33XfR1taGlpYWvP7664iODq0iIHpO4EqglhUj5epBIHPkAIQdJdoHqYV1Hahvd8Bs0GFGdjwfaGktrNUGUTcQQHWLwlOvkxRrQ4Hjde1ol1WEbNBB9A5WSDcZdDhrUhrSYy1o63Jj3ZG6bq+tbu1CW5cbBp2AMcmh7zU6nYBxqdLzrI1QC+9tLUNjhxOjE624YJpUULtGNmv+bG+lpkHiiU67w82LW9PCFNYA8En6gUr/38ZOWRE9e3TwwJ285GjYTHp0ujworPP/vgrlycq4CG2gDGVhbXJGLPLTI4cizc1NkHzWGuwjdrDLJiUpMWZs+d1Z2Py7s/DKtXNx+xnjsHB8CuKCjB+0MiUzFnqdgJpWR7fFwmAckq+xkxSFtblyK3FhXYfmFqXhxP4K/+K1FsVaraI4lmA1wiqPFdRMXllHAiumAb5WUFKs+XtjpUTLhTUNY+LXvy/CvEdW8XN/qKBUrJ1I9z/W4jxK/m5YUWPL8Qa4eqhmr23twuvfFwMA7luSz8caFc2dqgswrV0u7suXnaBQrA2h+c8xeexUr3FO16SYc/akFZT9XjLjo5Art02qUfKVBmkFjbcaEWMx+D0fiV2lzQCkhYe6Ngce/uIQFj6xGq98V8jnV1pZdVBqAz1rUhoPf2rocPaZIo6QGLIea8TQozpgwNKoQXnEPNbioroPjNnq757ylqAKkXCwNtDZoxNgMeq5p4TSL0kNgX8b+axJVPdQsdbhYIo1X2GN3dzaHW443T0bTBD+3kAHK+k87QuUkzy9TsCFsjLs0z2V3V7L/Edyk20wGcLfQifIhZgCja0VTrcXr3x3HABwy6KxvI1wVnY8po6KhdPtxX+3lWna5onM/ooWiCKQEWfhquRQMJ+17oq1ZgDB/dUAQK8TMEX2zgpsEzxWywpr6hbtkqPN3GNPbdCE0mdtywhVrZXJE9DcJKtfm19fYjUZ+ARSjc8au8YqFWsJNhP/fnuitB8u7Jd/Y8zyUItajBXAUmItEASBT/TUFJWDtYJmkGINQJDCWoz2wtqneypR1+bAv77X1n7Xn3Q43H5/w2C0gh6rbcM7m0s0W8UwtRU7xydnxCLeakSH08MtDrTy3Opj6HR5MHt0PM6elIoEq5HPr4pVthyytsXkaBNsZgO/plW3dqFlCCyAd7k8vBBV31OPtSgjkuS5R1uXW/Uck51rKTG+e3mBCiVfsFZQQRB8PmsNKgtr8r3pxatm47EfTkNWQhTq253464rDWPj4Gry8rhAdDvVzMpfHi7VHpLDHcyanIi7KiCij+sUMQj1UWCNUUyP/+NjKYE8Ua8EKa7lJViTZTHC6vd1WQCOh9FcD4GsFbXVouvmxgRpTVZFiTaLHraDyCohN0QoaazGCdWAxmfaJjMcr9ni1sTcoW5iGomLt/7aV4T9bSwd7NzRRJxfimeL14pmSR+e3h2q6DV4KVAQXMMal9Uyx9tHOclS3diEt1ozL5ozijwuCgGtPyQUAvLO5pFvL4nBlnyK4IBKTeWHN99uoa3OgtNEOQQBmyn5OwZg+ivms+d+HmFpuvMrCGgD85ZKpuOn0MdzLRA0j3WeNT0oU7Wz9wcxsuYAaoR20xe7ik+L8DH/VIVsQHMk+a2y8Nktur63S0ApaG9DOmSkXHSIFGHS5PFyNkqYosrMiW80JMklstjvx2vrjaNPgXRsOX2HN/7eT0oMuDuYF9eW+qiETesAKEsyjucnuHHCP2bv+sxt/+GQ/Vh+u1fQ+XliTi546ncA90TYV1mvej5KGDj7G+vV5+RAEAYIgcP9Pte2ggUWgGIuRF/+ODAGftaL6DrCvWHthTfpdJdhMiIsy+s6bDnW/NybOSIkxc7/cSIq1Docb9XLS8egk/99hTqL03ajxWWu2O7lX3rzcRCw7aTTW3LsYT1w+HTlJVjR0OPHYl4dx2uOrucVFJLYVN6K1y41EmwkzsxMgCAIy46Vr5khVyPcXVFgjVMPUS5MypIuMFsVac2foVlBBEDBXbgfVsvqr9FdjZtHMT8Lh9nLTfTWwAtLC8SkABj4V57X1x3HG39cOuQucsrVDywDQLh97q0KxptMJvLCq9uY2FGntcuG5bwsw5+GVWPy3tbwtc6BQphYeq20bUuq/docbv/1oL3738b4hseKpllrF6iQATBsVh7xkG7pcXqyU5fOMIyqCCxgT+IBMfWHN7fHipXWSIfHPF46B2eDv6XXxjEzEW42oaO7UPMA/UWEFkHDBBYwpGVLRpLypk5+DbPA5PjWaJ+YFY7pcIAhUETDFmprvnDF/TBJ+t3SSKk82xkj3WePtbIn9W1ibwRNgm8O+jqX2ZSVEdVsUHOkBBh6vyBd2zpmcDkBbK2gdV50FFNYijIGYksRs0CE2yrdwx9pCa9scJ8SCwzPfFuDhLw7h+dXH+mR7Zfy3469YY4vNahVrzXYnL0p0OD345mB1n+xfb2EFiXzZB8wr+jphBoLyJjs/37W0yLY73Px4sqIVACyQ20E3HNN+rX9q5VG4vSIWTUjxsx1gSY9F9erGG8HaFpk6aygU1o4pFiSb7C5NC9lNCjGHTicgwcraQdX9Dup44d/CFc6RFkjZbzDeauw2ztCiWGNK6twkKxJktZ1Rr8MVc7Px7S8X4e8/moHcJCua7C784eP9qgrM3x6Sxopn5qfyImOmBpUwoR4qrBGqqZZ9yJjXiJbiSAuX5XYPLwCAuXKAwXYNhbXCunY/fzVAMq9mveyBvmnhYEXDRROkwlpBbXuPk/x6woc7K1BU34Hvj2lfvepPlB5rPQkvsJr9J5UJJ3CAQbPdiae+OYJTH1uNJ1ceRbOsZtg4gN9Zl8vDB3VGvQCXR0RB7eAPgBgVTZ3wioAo+gYZJwLsWsEmIYIg4KIZkmrtfwHtoDy4QIVijRViCuvaVU/2VuyvRkmDHQlWI648qbvayWLU4wrZvP3fm4pVbfNEZ68GxVqc1cjboQ5USe9jhbVQ/moMplg7WNXKB/HtLp83y9ggaaJ9ydzcBOh1giqftRa7a9ilV5c1MgP2qAiv7B0zFAXUcJMS1gY6KaO7Rx5TrO2vaBnwxZWhwPG6dnS5vLCZ9LxIUKmpFdT/mst+s5EKa8o2UEHwhZCkRJuhEwC3VzwhfO92yJ6Pm473voje1uXixZtQijW1hbXAif9HO0OnYw8kJXIRaHxqNB/jD2SAwRrFIlahhoAApsCMizIiRlFsWTBOCjDYUdqkyePqQGULPt0tjUnuWzLR7zl2f1KrWAtaWEvve5+1F9cex+rK7oFBkQgsZGkKzLP7wgsA8HZQtdtQLraycVykZNDShu7Hk8ELayo81lhhjSVYKzHodbh8ThY+uu1UxJgNOFjVis/2drcsUSKKIlYdkhaIz56Uyh/3td+fGCrfEwUqrBGqYRJ7Nshsd6jvVw/nsQaAK9Z2lDSqnixsktVqzF+NkarRZ00URT7Im5ubAKtJD6fb62eU2t+wwaKWVoqBwK8V1KE9vMCqaAUFfIrFZpWFtXc2l+Cnb27rs3aJnlDf7sBjXx7GqY+txrOrj6Gty43xqdFcsbC+YOAKawerWuH2ikiONvEiwVDyWatotiv+/8Cvgu0tb8a6o90DByJRFyRl7mK5sPbd0Tre9u71irwVdEKYRFBGVoJVUzKoKIp4cY2kYLjh1DzYzIagr7t6fg4EQTr3jtcNnQSv/qCpw8mP3fRR8arew3zW2G9jV0kzAGB2CH81Rk6SFTEWA5xuL1ct18in8aj4qJDfR18RYzFiqlzc2xxiwt3p9OD+j/Zixp+/wYtrC/t1fwYaVozP7mfF2vjUaEQZ9Wh3uHE8jLrjUJBEUEZmfBSyEqLgFX3BGCMJ1i49OTOWt7jVtztUK6hrA9rv1bYlsbEaU7oxDHodLyIFeuYONRxu3wLZgcpWTV5JwWD32gSrEdEB1ygeXqCy2Mj8udike31BnWbP4v6AKdZykmzcr3cgF2i/9Susqb/nsjGRUq0GAGOSbUiLNcPp9mq6fvz96yMAgItmZPJ7hXKbAFBYr7awJi9kKK63+TwZtG8KayUNHfjHt8fwaYlecyG0MKCwpsUnkCnWWGEtUWNhrV4xJsxN8iWDhls8KA3ir8YYLbeClqpoBWXBBbPCLAQm2ky46fQxAIAnvzka9rpbWNeOkgY7THod78oCgIw4Uqz1B1RYI1TDBivj06K5lFRtwiNrBQ2V6jUlMw5mgw5Ndpfq1SA28WAJOwzt0ncXvyilx1kwXlaiDFQ7qMPt4Rf76tahdYFTmlr2SLFmCqVYU3fevLS2EN8ersUXe6tUf3Zf0Wx34i+fH8Rpj6+WjEKdHkzKiMWLV83G1/ecjp+dlgcAA6oyZK1LM7LiefrhUPJZU/rjlEfwyulrWuwuXPnKZtz45jZVaX9KlH4ajHGp0ZicEQu3V8SK/dL5V97UiU6XBya9zi9OPRR6ncBXkdUEGHx7qBaHq9sQbTbgOtlLLRijk6w4Y6K08vj25pKI2z2RYRP43CSr6lRI/tuobIXT7eWtpJEUa4IgcFUc+9yaTulepza4oLcwW4NghbUj1W24+Pnv8Z+tUnDFin0Df13sLzxekQ/w+7uwZtDreFDE7rLQvq4HgySCKjlpBPus7a+Qjs2UzDgkWk0w6XUQRfWpnEwRwrzRRsVL37laxVpqkHCLdHmiONTNuA9VtcHlkRaQPV6RT6R7SnljcH81QOGxprKDgynWTh2XhJnZ8fCKwP92h1fEDATF9dJ+5SZbfSmP7QNTWLM73dhY6LseF0ZQLikJTARlCIKABWMl1Zpy2+HYWtSINUfqYNAJ+NU5E7o9nyd7rBXVqdu/sqCtoD4/sb5QRO9QFA21elcfCyisqfVZ63J50CmrANmYITFa2zmjDC8wGXS8zTacz1qw48lgirXyps6w3VCiKPLxSjDFmpIbT8tDcrQZpY12/HdbaF/jlQelovApY5P8Fgf5YoaGFn4iMlRYI1TR5fJw1VlGbJSvX13lRYoV4OJDKNZMBh2/iGxXMUgVRRFbAoILGMxnTe1AoloRXGA26JHPC2sDU7BQ7udQkuS6PF4/P4LWHhTWbN0Ua+pXGrtcHn7BH0hVGOO25Tvxr++L0OXyYnpWHF69di5W3HUalk7LkMxnxyZBrxNQVN/Bb6j9DS+sZcdzk/ahpFgrV0yKIplQ9zX/t70MHU4PPF6RG7+qhRtpB6ggWIgBm1iwVdyxqdE8qTMSzPA+kj+HKIp4XlarXX1yTsQi0jWn5AAAPthR3uP49ROBvfIgc5oKfzXGFEWAwaGqVjjcXsRFGfmKfjiYjxtrP622S4U1LcEFvYH7rB333QdFUcR/tpbi4ue/R0FtO5LlScLBqtYB9RnqT2pau+DyiDDoBB6Q1J/MYAEGIXzWXB4vV6ey8ymQebJqeWvRCCysyYmgU0fFQacTuMeZ2qIWU56lBCjWqpq7wrbn1siLIGlB0oHT5eu32uLeYLE3IDRjay8Ls9ybMEgLNbun1bc7VHkxFSuUYT+cLQXnfLxr8NtBmWJtdKINiQNsKfJ9QT2cbi9GxUdBrxPQ4fSoDoMoD0gEVcJ91lQEGIiiiCe+OgwAuGJeNnKD3Mtyk2wQBGmsHkkd5vGK/LxRFoLGpkRDJ0hzNi0KsVAoC2uHqtQX1tweLx/Hsft2vcr5Jrsn6nUCYuW2YdYKqsZjrdPp4R7d7PrECo7HwvjlBmutZaTHWmAy6OD2imHnecUNdjTbXTAZdCEXdBg2swF3nTUOAPDMt8dCKl+/ZW2gk9P8HteSxEyohwprhCqYAsRilAxjE22yCb3KG1sLDy8I7rEG+NpBt6uQRUv+ak7ZX81fDq21FTQwuj1fDmc4NECKNeUgUKvSpj+pbXNAuWClKbxAnuhHdVOssVbQyNsqb7Lzz//+WP2AGhLvKGnExsIGGPUC3rh+Hj69/VScMznNz9MlxmLkaWgDpVrbI0/2Z2TH8/akQ1WtQ8ZrSTlgULaF9jcer4i3FH5jWgcKSqNaJcxnbWtxI6pbuhT+auqLLEwBG0mxtul4A3aXNcNs0OGnshoyHIvGpyAnyYq2Ljc+2TX4ioL+gp/zKvzVGEyxdqyunXsYzRodD50uss+LLxm0GQBQLZ9KWoILesPcHMlnrbTRjormTrR2uXDHf3bh/o/2weH24vQJKfjqntORl2yDKErXquEAW5zIlCev/Q3zWQuVDFpY1w6nx4sYsyFowQLw+aztLmtWbYsxHPB6Rb6gM3WUdB/K4IW1yNdet2LRjhV+0mMt0AmA0+MNq0ypDdEKKu2D9D0NpXFUMFgAETtm23pZmPUlgnY/T5Ns0nFye0XeORIOpljLTbLhwumZMOgEHKhsjZiI2J90uTyoksfJuUlWzW19vYWFBJ0zOY0r1QPbFENREea7Yd02e8tbIo6vvz1Ui+0lTTAbdLj7rPFBX2Mx6pEp/wYiLS5WywsZJr2Oz33YNljRri/aQXtaWCtttMPp8cJi1HEVuVrFGpuXxkUZ+Zid/Q7UnDNsPGgx6hAjK7zY/T/c76AkTGFNpxP44yWNob+b3WXS8ZqSGQuTIXKJZtm80RidaEV9uwOvf1/U7fmGdgd2yB6zZ+Wn+j2XqfBYGypziOEAFdYIVTBVV7psGMsUa2pvbMxTK1gqKMMXYBB5kMH81ebkJHRLzWOTY7UrSqywxVZcJ6YPbCuo0g9kKElyAwenPWkFtQWGFzBvDBXnDZP+A1JhNtQEqD94ae1xAMAPZ2XhjPxUv4KaktPGS1L+7wdAUaeM4J6RFYdxqdEw6gW0drkHxc8sGBWKwIKBbAX99lCN3+dpKax5vCIfsCk91gBpRW9ebgJEEfh8byUfVI1XEVzAUKtYe3GN5Jf143nZfi2podDpBFxzsqRa+/em4mE7MNqrIRGUkRZrRpLNBI9XxHtbpRaJORHaQBnT5EH8keo2OFweVPNWUPXfeW9Q+qz9a30RLnh2Pb7YWwWDTsD95+fjzevnITnazNsQtwwTtVRZE2sD7d/gAgZLBj1U1RrUPPyQog001PV/bIoNSTYTHG4v9leEbikdbpQ02tHucMNs0GGc3OrOJmlqFGsNHU6IoqQoYRNeg17HlYrh7meBC6FK2GNDvrAmX9OuX5ALANhV1qQp8TAQnggapBXUZNDxBU01CiSfl5lUwFosWw4MZogBW2SNMRuQaDMNaCuo1yvywtpZk1IxRm63VOuzFq7omZVgRU6SFR6vGLadvKK5E7/9aB8A4PpTc4Oe+wy2f5G8V5nRflZC94WMiX1kh9PW5fIrzh3S0AXE2kDHpkTztu96DfY+gP98U0srqNIahF37x7OE9xDjOK9X5C3ZwQprAHhRNpx/927mr5atbrxiMujwq3OltuBXvjvebU6+5kgdRFEq1GUGqCbZnLfT5VFt60REhgprhCoCBzNazEO9XjFieAEg+d8IgnTRORzhArw5RBsooL0VlJvhygW5/HRpBba00d5rU1k1VAf4mA2VhDG2X2ywq0Wxxo5blDF4eIEaj7XiAJPP9UcHRhV2tKYNqw7VQBCAmxaNCftaZgQ6EIo61pqWm2RFvNUEk0HHJ/tDpR1UOSEayGLfmxuLAYAbN2tJp2vocMArAoLgu64puViRDsoGmmoSQRm8haA2eDKoKIp4c0MRvj9WD4NO4Ia0avjRnGxYjDocrm7DNg2JyicKNa1dqGl1QCeEbscLhiAIvFWaDWIjBRcwRsVHIdFmgssjYntpM1qcA+uxBvh81l7fUISyxk5kJUTh/VtOwc2LxnLV3UnDrA2RKdaygxQH+oOshCgkyd/zoSA+lb5E0NC/dUEQuNJ+a9Hw+/2FghURJ2XE8pZ43gqq4rrPxpPJ0Sa/SX2mipS66jCFtfS4oR9e0O5w86LMD2aPQoLViC5X7wqz4Yo3gPpk0LYuF2+3Y55Ql8ntoJ/urlDVStofsEXWnGQrBEEY0PCCA5WtqG1zwGbS46S8RO6ZqtYLuoK3gga/rrF20I3HgvustXW58NM3t6G+3YH89BjceWZwtRpDbTJoWRij/Ql9VFjbXdYMUQRvxzxeb1edgHpM/o2MS43m1gdqFWvNAYmggLZU0GAdDBNYMmgI77mati44PV4YdAJXogaSkxQ5wGAXSwQdHR9xPxkXTc/E5IxYtDncPPyKseqg1AZ61qS0bu+zGPX82A6VxfnhABXWCFXwIot8wUjQcJFqd7rB7sfhCmtxViM35L7l7R0hvWPC+asBvhQkta2gfKAW5ysasoHIQMjfA5V11UNEtaYMqwCALpdX9apqSMWafKNTkwrKWhKYiui7Au1pjz3h5XWScui8Kel8kBKKGVlxiLEY0NLp6nfFgtJfjcHaQYdCgIHT7fU7l5vtrgEpEh+pbsPGwgbodQJvodSiWGMF+CSbOahv2tJpGdDrBOwtb/G1gqpIBGVkJ1phNujgcHu5pwmj2e7EzW/vwJ8+OwgAuPaU3KCqg1DEWY24dKY08fm3ohV2uMCKyeNSozUnck5WFOJ0gv/vJhzKAINPZW+91Bhz2HtXX3OK4r52wbQMfHHXwm4JYaywtq+8ZVh47A1UIihDEARfO2gQnzV2TZ0coaA7bwQGGLB7HWsDBYDMOGaEHXncxa65ga33zOA9nI1AuFbQ9Nih3wq6r7wFoigV8FNjLJjbB+ePr7AW/Lfj6+IIf1zYmCvJZkKMRbrenTkpFbEWA6paukImFfc3St83wLcApjVlsieskv2pFo5PgdmgVxTWIivWulweXqQJDC9gsACDDUECDNweL+78zy4crm5DSowZ/7p+XrfU10CYyf7xCK2g4fzA2Pimt/Mf1ga6aEIyog0iPF5R9TaZl9m4lGgkRzOfQHXfd1MQT28t7cMsQZfNJQEgN9kGo17y1wt2jWMKwFEJUSH9d1mxuiSEYq3L5UsLnqVyvAJI3Qu/Pm8iAODfm0t4kazL5eHzpnOCFNYAbUpjQh1UWCNUoWwFBeAzD1VxkWqRL3IWow4Woz7sa/92+XSMio9CcYMdd7+3K6jC41it5K9mMXb3VwMUijW1raAtbAXUdxHNH8B20MBB4FC5wLFVZWVxSW07aKhUUJ9iTUUrqDyYuvKk0QCk1a/+Nuoub7Jzo/pbFo2N+HqDXscnwf3ts8baR2YoWuKGUoBBVUsnRBEwG3R8hXIgAgyYWm3JlDSuHtFSWKsL0QbKSIo249Rx0uDXKwJRRn1QI+JQKJNBjyqMb7cXN2LpM+vxzcEaGPUCHrhwMv544STV22WwEIOv9lfj20M1w6ollA0yp2aq91djTFG8Z0JaTMQJiRLms/a1nKY1LiVy6EFfsnB8Cu48cxz+8eMZeP4ns4IW9bISopAZZ4G7D1IFhwK+ZMOBaQUFfNdS5uPHEEWR+wFFMpBmBc7txY2DpugZaHhwgeI3lsETOSNfe32JoP7X3EiKtXaHT9EfPBVUbgVtHbqeQXt4a7t07Ob1UvHY2uXi46LeKtbYhJ8VAADAbNDjgumSavujQQox4PslF4ESNViK9BbWBnrmJGnRf2yq3AqqwmONjeWjjHrejhsIEwccqmrtVvR5+ItDWHukDhajDq9dO1fVuEN1K6iqwlp7r65prLA2e3Q8Rtmk7agdqyoVa0m8sKa1FbS7Yk1NMbY2IFgFAIz68Mmg4Y4nY7T8uyoNEXZ2oLIVLo+IJJtJ831w0YQUzM9LhNPtxdMrjwKQOrvsTg/SYs1+iyBKmLqOAgz6DiqsEaoI1QraqKKlz5cIGjq4gJEUbcY/r5kDi1GHtUfq8OQ3R7q9hq2aBfNXA4CUGNa66FYlO2YpU8okMtbqpTUeuicEti1UDZFkUDYoyEqI4gUyte2gvsKa/2TWp1hTb6K7YGwSxqbY4PGK2KQiPak3vLa+CG6viFPHJalWuCycILWDfne0/xR1oihid5kvuIAxlBRrFYr0K7Zy3t8BBs12Jz7eVQ4AuH5BnmJi1ql6YlUXZBAVCGsHBaSWADUm+EqY6rOgtg0er4jnVxfgx69sRmVLF3KTrPjo1lNx42l5Ib2cwjElMw4LxibB7RXx07e24wcvbsT6grohO7HUAhvATtCgEGQoW0fnqGwDZbAEUnYdGzuAbaCAVIz91bkT8YNZWSHPCUEQeFFnOPisDbRiDQidDFrT6kBjhxN6ncDbokIxOSMWNpMerV3uPjH7HuqIooj9FSy4QFFYi1fvb8bGkymBijX5+h3Kn7NWfl+02RC0UM7GcHanR1OKeSje3VKK33ywt08tQQI9I5nicUdJzwqzbPEq0WYKqepVW1hji5m5Sf4LCSwd9Mt9Veh0DnxIBzOFzw1QrPV3eEFNaxf2VbRAEMC7acYkS/eCypauiEph9t2MSogKeR1PiTHz+YZSEfjWxmK+aPiPK2aqHo+y4k9pox3uMB0mpWFaQXMSrTAZdOh0eXrslev1igq/sHiMkk8pNWNVURR54XJ8mrIVtOee3uycael0Rey88bWC+o8Jmc9asCCqcK21DFYYLmmwBx2f7ZbvQ7NGx2seCwqCgN+cnw8A+HBnOQpq2vDtIbkonJ8WcnuZlAza51BhjVAF8yFLj/MvrKlSrKnwV1MydVQcHr9sOgDgxbWF+Hyvf+LdZjm44OS87m2ggNTPb5bTVNT4rFW3sNVT3yAvXy5YDIRijQ0yWaT0kFGstfiKqTGyAkm9Yk16XaBijRfWOl1hJ/5ORdtcbrINp8vFq3X96LPW0O7Ae9sko/NbF41T/b6FspppZ2lTv3nyVbZ0ob7dAYNO8CsYsMJaeVNnv6v5IqEcRLLVtv5WrP13Wxm6XF5MzojFvNwEnojVoWFixdpjQinWAEkNxxKaIk20g8Hes+V4I659fQv+/s1ReLwiLp2Zic/vWsgN83vKS1fNwU2nj4HFqMPusmZc86+t+PE/N2NTkPaSEwlfCqv2Y56XZOPXn9kqgwsY0wO+j4FWrKnlJPkeuLXoxP6eHW4PX2AaKI81wKdYO17fwZX1gE8pOSbZFlFlb9DruH/fSGgHZfcao17wS8plirX6dmfEhNTaEBPXUREmeWwcmhqkDRSQUsjZOLOmlz5rx2rb8MdP9+O/28vw6w/29tlCxR6+QCZdY6aOioPFqEOT3aXaEF9JJH81wNfSVhdB8VMS0HLJmJuTgOzEKHQ4PfjmYLXmfewtykAFYOAKa2tktdqMrHhenEywmbj6KZKPGVtYjKQ+WjBO9lmTF47XHK7FQ58dAAD85rx8nD8tQ/U+Z8ZFwWLUweURwxbFysIorAx6XyhJTxcLCmrb0eZww2rSY2JaNEZZ1SvWqlq60OH0wKATkJNk4+dvY4dDlZcxW7hXqgTjrSaw9dBI81ZleIESXzJo99+pGsVaVoIVOkEKCwhW5N4lp3fO1NAGqmT26AQsmZIGrwg88fURfCu3MZ8zOTXke/g1d4jMO4cDVFgjVFHd4q9Y0+Kx1twpRx+HSQQN5JKZo3CzbOJ93/t7+UBXFEVfcMHY4IU1QRD4wKuuPfzFwqWIffcrrKUzxVprvyo/RFHkA0BmVqmmlWIgYBOdjDgL99toVaFY83pFdLqCK9bYCpLHK4YtfFQ0d8IrSu3DqTFmnD7epwrrr+/jrY3F6HJ5MW1UHE4dF/zcCkZOkhVZCVFwecR+MxJnior8jBi/iV6c1chvjMEMuAcSpWKN+Yn0ZzKo2+PFvzeVAJCSsgRBQJTJ13Kh9nfEVydDTNYAKalxyZR0AOq9upQw4/t1R+uw4VgDoox6/P1HM/CPH8/U1KIYijirEb9bOgnf/foM3HBqLkwGHbYWN+LKVzfjJ69uxo6SE2/C73R7+cRFOYFXi04n4Ccnjca41GickR96YBmMtFiL36R/7JAtrElql12lzRGLGUOZquYuiPL1nqkTBoIEm4lP1vdWNPPH1fqrMVhC63AJkgjHAbkNdGJ6jF/HQILVyBc0I6nW6tqCBxD4PNZCKNbY+wKUbkpYa1Nvfdb+uuIwn8R/sa8Kr3x3vFfbA6RWtormTggCME1W+xn1Op4AuLUHhdnypsjFG7WBXizoJTfZvzggCAJ+IHt5fjzA7aAuj5ePI3KT/RVrnS5PvyrovmVpoAH3D7XJoGy/I7VwMp+1jccacLi6FXf+Zxe8InDF3CzcEiFAKxCdTuDKvqIQPmvtDjdviQyVwtxbnzXWBjozOx4GvQ5ZcivooarWiMpMlqCek2SFUa9Dos0EQZCsONTYyDRxxZrvXqLXCXxhP1I7KLcHCRgTsgXSYAnvagprJoOOK8RKgrSDMsXaTJWJoMG4b8lE6ARg5cEaVLZ0wWLU8fMrGKRY63uosEZExOsV+YCGK9aYx5qKi1xzECNJNfz6vHwsHJ+MTpcHN729HU0dThyrbUdDh+SvFqgqUMLNWiMMJOraHBBFwKgX+CoUIE2EdYJkgqkmoryntHa60eWSZMnMrHIorByIouiXvqVFsdbl9oDVvgIVaxajnj8WLsBA2ZIgCALmj0mESa9DRXNnyMFCb2h3uPGWXKS5bfFYTTJsQRB4Omh/BSzw4AKFvxpjqPisVSgGkbylpx9v1qsO1aKiuRMJVqNfq6bWgQJTTyiNaoPx8KVT8cyymfjxvGzN+6pUXOWnx+CzO0/D5XNCt/n1lNQYCx68aArW3bcYV588Gka9gI2FDbjspU247/09J1R7aHFDB9xeETaTNk87JX+4cDJW/XJR0LTXSExX/NYGMhFUC2NTbEiymeBwe7EvwCfsRKKMFwesff6biAT3WVO0g7LCWiR/Nca8PJ8B/Yn0G+sJvA00wPdQEARVqZ6AQnkWoAhh72/pDB5847MkCX2tZsW63hTWvi+ox+rDtTDoBL7A+/hXh/F9Qe8U86wNdEyyjS9WAorzpweF2TLuTRh6Qt9bxRoA/GB2FgBgfUG96mCwvqCiqRMer8gXWQGpFdiol64Tjf2UDNrl8vDvm/mrMdQmgypV/OE4KS8ROkFSzl77r61od7hx8phEPHzptB5dDyMV/phaLVERUhFIb5NBWWGN2TCkREn+ux1OT0iPMcaxWp+/GiAp6FhRTI3Pms9jzf9vU6t0rONjQv8Cfrhk0FL5dxiusAaEDjCob3egvEkquk8P4h2ulnGpMbh8Thb/98LxKWFV1+Sx1vdQYY2ISKPdCZdHhCD4BkIJNumC1dDhjDiQZC1qgRe5SOh1Ap67chZGJ1pR1tiJO/+zixvEh/JXY7D9jBRgwIpHqTEWP98ki1HPV8f602eNfX681cg/byikgjbZXXC6pYKfVFiTvjs1hTW7YgUxKsgFPYEXZUOr30rk4hm7SVlNBszLk27Q/eFl9t7WUrR0ujAm2YZzZWWSFhaOl1aEejvwDsXuIImgDNYOOtiKtcqWgW0FfXNjEQAp3EI5cGAtSRUqvQp5W1IQM2wlcVFGXDJzFIwhEp/CkZNkxa2Lx+LOM8fhk9tP7fdCTUZcFB6+dBrW3LsYy+ZlQycA7+8o71Gr0WDBVsrHp8UMeLEF8LWD2gyi36LLUGK4+Kyx4kD2AAYXMNg1lXlYAsAheZFissrC2szseBj1AmpaHSEnjaIoqvJ8HerskxNBp4zqPvnjarHW8Nd93n4fUCCLNht4K2ewiV5Na/fugkCYz1qgd61aPF4RD38hpTRffXIOfnt+Pn40JwteEbjzPzt5UaIn7Anikwr4FI/birUHGKhRrKnxWLM73fz45iZ1Lw7kJdswMzseHq/IA54GAqbsyUm08fuAIAi+IolK3y2tbDregE6XB+mxlm7XAbXJoOXN6hRrcVFG7utZ2+bAmGQbXr56Dref0ArzgQuVDMqKOuH8wCamy62gPZz/7JTbGlmbvF4AJsqFqUg+a6ywxjzNAPh81trUd0klWP3v22rSZD1ekXu5BbaC5iT5kkGVqlq7080LfpE8QlnRmhWxGcyPblxKNGJDFDvVcs/ZE/i5c3ZAUTgQdm7WtHaF9eRTi8crotnuRGmDPejiyEig9z0oxLCHrfwl2cx8UskuUE63F3anJ6RpKqDdY01JvNWEV66dgx++uBHfH6vnF2uWxBgKX2Et/OCKmeEGawPLT4/B8boOHKlu4x5ffQ1XhcVY+KB0KIQX+L5zE0wGHVestarw8bI7fImgwUze461GVDR3hlU7+loSfCunC8enYMOxBnxXUI/rT81T/8dEwOH24NX1UpvHzYvGQK/RmB6QAhYEQZKIV7d0cWVnX+DxinwyE8x7YdIQCTBgRbTM+Cje3thfraCHq9uw+Xgj9DoBV5+c4/fcqHj2O9LYChrGY623CIKA35yX32/bD0VWghWPXTYdx+s6sLW4ETtLmzEuVbtf2WBwtLrn/mp9wcLxyfjHqqMYFzu0FUgn5SXiy/3V2FrUiNvPGOy96RmDEVzAmCmrA3aXNUMUJRuDInnSo1axZjHqMT0rHjtKmvDq+uPISrCiprVL/s+BmtYu1LY64PR4kWA1IjvRiuwEK7ISo5CdYEV2ohUZMUa4ez+v6Vek4AKWCNr92KRz9UPoMYxy4hqsQJYZH4WWThcqmju7+VnyhdBwhTU2juqhYu3DHeU4XN2GWIsBd581HoIg4C+XTsWRmjbsLW/BLe/swIe3LojovReMYMnegGRWrtcJqGjuRGVzJ1fuqYHdY8N5E7ICQUunCw63J+iiNCsIx0UZ/VrolPxw9ijsLmvGx7sq8LOF2loUe0qgvxojwWpCTauDW7n0NauZ8fuk1G4LO2qTQStU+N8xFoxNwp6yZsRbjfjX9fNCfgdqYAEGRSEUdeH81Rjst1dY1w6n26upyNfQ7uCdJbMVbY2TMmKwt6IVBytbsTSMb1xhgGINAJKjzTha065KscYW7QPnnEnRrBgbehtNdic8XklIkhRgS8CSQY/WtKOgpp2rRNnCUFyUMeI8VxlgoMTXBhof9v1qyIyPwuOXTcP3BQ24eMaosK9NjjbDqBfg8oioaXOo6g6obe3CM98WoKbVgdYuF1o7XWjrcndTGr941eyw3/NwhRRrRESY/D49zjfxjDLquZ9GJFltc5B+dy3kp8fiyR/NAOBTQ50cqbAWq64VlBWQ0oMM1CamSQPH/lSs8YCAOAvSZaVNm8OtOn0TADqdHvzk1c14Yc2xvtsv/p1LxyVWQyuo3RU8uIDhSwYNfd4EG0wxn7VNhQ196if06a5K1LQ6kBZrxqWzwt+EQhFvNfHWsfV93A56rLZdKl6b9HylVAkLMyioaecqw4HG6xX5ZErZClrf7ugXlcbbm6WQifOmpHebhGhpBRVFURFe0HfF0KHGrJx4AD5z3BOBI1yxNjhtmLNGJ+CL2xfgyrFDu9oxXw4w2F7c2CcrzoMBT1QbwOACxpTMOOh1AurbHahq6cLh6jaIolSMCJcUHAhLd3xncyke+/Iw3thQjBX7qrGjpAnlTZ1wyt9Nk92FveUt+GJfFf657jj+8Ml+XPf6Vpz7zAY8tFOPPUO4pVcqZEhpqcGKjiw8Jpy/ZYNsQC4ICKoEZQsjwa7fbCE02HiNwcYsPQkv6HC48Xc5if6us8ZzL2GLUY+Xrp6DRJsJBypb8buP92lu+RVFEXvl7zbQxsRmNvD7uNYADDWKtbgoI0zyongo1VpxPUveDP0bvHB6Jox6AQcqW3vsvaUVvl/J/u2prOihxo5GK6IoYrXsrxZM8cPGYUX1HSH9wtweLy8Ej4qPfF278dQ8XDV/NN6+cT4vjPUU1gp6vD544c/nBxb6nBklL5C6vSK3ZlHLTll9NT412s9be5Ls2xZpEbigVjq3AgtrQORWUFEUeRBNQsD1JckmbSOcYo3NGROtpqDdCeO5z5rv/Ffjr8bgraABytddZbInney13Vt+MCsLT14xA1Eh5mEMnU7gXR5q20Ff31CM5VtKsepQDbYWNeJwdRsqmjv9impRRv2gzUcGG1KsERGpDjKYYVLsqpYuNNmdYVeam0OsHmjh/GkZuOOMcXh+zTFYTXo//5tgpKhuBQ3dWsDMO4/U9J8SiBewYs2INhsQYzGgrcuN6paukN4HgWwpasDGwgYcq23H7WeoT7MMR1VAwdHXChq54NfhCB5cwGAtwY0dYVpBA+LVAWm1KznajPp2B3aUNIU15FSLxyvi5e8KAQA/O21M2PbiSCwcl4w9Zc34/lg9fjRXuw9XKJj3z7SsuKBquqyEKMSYDWhzuFFY165aZdGX1LdLagydIE1sDDoBVpMedqcHlc2dGBOkINhTOlzAp3uqAEihBYFkqPT5AaQiNvM41DKJPtFg5ti75AHviUCBnLzFrsODwfi0aBQM8VHSxPQYxFoMaO1y42BVa8R741CkjKluwkz0+guLUY/89BgcqGzFnrJm7tmktg2U8ZOTRmN3WRP0OgFpMRakxlqQFmtGWqxF/s+MGLMRlS2dKGu0o6xJ+t/yJjvKGjtR2tiBVpcX1725HW/dcBLmyoW6oQRTq41PjQ6q2MrgauHQ1142cU2ymWEIMnFlizLBbAR8raChr9XpvQgv+Od3x1Hb5sDoRCuuOSVQCR2F56+chav/tQUf7azAjKx4XLcgV/W2y5s60djhhFEfvCg5LzcRe8tbsLWoEZfMVLfA19Lp4iFQ4Xy8BEFASowZFc2dqGtzBPVjK20M7a/GSLSZsHhiKlYerMFHOyvw2/P7X4UdSrGWyIok/dAKeqRGKhSEMn7PSrDCpNfB4faiorkz6PynurULHq8Io15QpYZPiTHjkR9M65P9Z62gNa0OdDjc3TqK1BSCBEHAhLRo7CxtxpHqNk1p6MxfLTCNm3dXhPEDbmh3cMXZGEVoULJKn0C708MXMRJCeKyFK6yx7YcaD05IjcEXqPJLBmXn6OgwRWnG6MTuraBer4i9cpv4rF4EF/SUjDgLShvtqgtr++Sgn2XzsnHa+GTEWiSlXmyUEbEWA2Isxh63MQ8HhviQkRgK1AQkgjISrFJhLaJirYcea4H88pwJiIuSvMgi/WjVeqzVtgb/2wCpkANIEzy3xxt0ENhbAouWmXFRONLVhqqWLr4yEoliWXLdZJf87vrCj4i3qMqD1BizBsWas3eKNY9X5AoG5WBKEAScPj4ZH+2qwHdH6/uksLbyYDWO13Ug1mLAlfNH92pbp41PxvNrjmHDsXp4vWLQNtiesJu1j4SQiAuCgEmZsdha1IiDla2DUlhjXiLpsRa+ypeVEIWjNe0ob+rbwtqmWgEOtxdTMmMxN6f7IIQrHlR4FbJJXozZEHFl70RmtqxYO1LThrYul+qi/WDR5fLwVfLBagU9UdDrBMzLTcS3h2uxtajxhCyslTf6wgsGgxnZ8ThQ2Yrd5c1ol+9xWq+jo5OseO+mUyK+Ls5qDLrt5vZOXP7stzjW6sG1r2/F69fPi6jMH2j2y4mgUzKDm2v7FGuhi1qRWu9DKY6VCer94bFW3dKFV+RFtvvPzw+6yLZgXDLuP38SHllxCH/5/CAmZcRyj8NIsDbQ/PTYoEXJebmJ+Nf3RdiuwWeNFR+TbKaQC5mMZEVhLRjcfiNCceCHs0Zh5cEafLq7Ar9eMrHPxjmhYPeBnET/gl+iPJ/oD8Xat3Ib6Kljk4N+V3qdgNxkK47WtKOwrj1oYU1pjdHfxyiQOKsRSTYTGjqcKKrvwNQAP0SuEI6gsJqYHoOdpc2a1Yk7A4ILGBPSoiEI0m+zod2BpCCBUcxfLSshyu+cTo5R57HGzgeTXtfN49nXChqmsNYWvrDGFPQFimOiprWWweY0zXYXWjpdiIsyorCuHW0ON6KMeh6QMJDwxQyVXR4swObqk3O6nVsEtYISKgimWAN81f9IN7aWPlCsAZJk9eenj8E5k9MivtZn1hp+cFUdpM2VkZ1ghdWkh8Pt5YOOvqYmoIDl8wdR703FvAxcHpGvXvZ6v+SBcQZXrMmFNYcKjzWnz2MtGAkRBkSVzZ1weUSY9DouUWYwr7u+aLcURREvrZUG0tctyOW+YD1l9ugEWE161Lc7cai671SOTLE2M8yEefIg+6yxSZCyLVPLzVotbo8X66ul29b1C3KDFpHZPlS3SCvG4eCDqDAKiOFAaowFWQlREEWfgfZQprCuHV5RumcMZyVhX3EiBxh0ONxcQTAYHmuA79q6u7SZX0MnB/EQ609sZgNuzvdgwdhE2J0eXP/G1n4Lw+kp3F9tVPBjo2b8wlrvQ6nOmPIq8L7R2umGwx1ZXcy8ahs7nJpsCP729RF0ubyYl5uA86aGDjD62cI8XDQjE26viNuW71TdchqqDZQxN1cqQhypaQtrk6GkTEUbKCNSMmi4RFAlZ05KRazFgKqWLmzV2LaqFWmRtVPer+CKtUgL+z3h20M1ALqngSqJlAxaoTK4oL8IlQzq8Yrcly9SIagnyaAuj5cXkWcHFNaizQbehXKoKvg2C4L4qwHqW0GViaCB40M1qaDs+hRSscYKa7XtvA1YSyuozWzgf0upPK/cpehK6Q8BRyTYmFmNv3d5UydaOl0w6gVNKsaRBBXWiIjwdsm44IW1cC19gCIVNGrgktWYX1JDhzOs70x1mBVQnU7gqrGeJuNEQhleAACZrJVCQxtDkaLo19RHg4yqgIJfbJSWVFCmWAvVCho+FdSXWBTVrfXxNDl980Bla9iEKzVsLGzAnvIWWIw6XK+hpSMUJoOOKwz6akLU5fJwj79QijXANwkMJ7HvT4LFyo/qh2TQVYfr0OwUkGA14qIZmUFfkxpjgV4nwO0VI54jfBAVZOV0uDFrNGsHHfo+a2yFfOIgJYKeaLDC2rbixpCeP0MVNsmLtRh6vfjWU5ivzb6KFn6vn5wx8JMGkx545apZWDwxBV0uL258axvWHqkd8P0IBVMqhFIpMMVak92FTmfwohZr5wzlaZkZopW/ps2XoB4uOCAuysj9fyN57DL2V7Tgo13lAIDfXzA57DVHEAQ8ftk05KfHoL7dgTve3anKb21PmGRvQCocsGKIWtVaOTfHjzyhZwFdoY6Jz8ss/LbMBj2WyMnpK/ZVqdrPnlLd2gWnxwujXujmpZpoY5YifVtYa2h38ELHmflqCmvBfcz4mGiQCms8wCAgGbRGPqYGhbdWKJhaXIti7WBlKxxuL+KtRowJ4hXnWwQOvsDHFGvjArocUnpQWAvE1woaehs+RW3w6xNLBrU7PbwrQkthTdoG81mTvhtm0TGrD4ILekJGGF/LQNjiysT0mBHd7hkOOipERGpCGPxzxVrEVlAWXjBwg+Ykmwl6nQBRBE+gCkZthPj2fF5Y65+CBRtkspXe9Fj1KweMYsWNM5x3gKb9CuGxpkYRF1GxJg+IQq3KMul/bpCV0+RoMzf5/f5Yz1VroijiHyuPAgB+PDc7qCS9J5w2Tir8re+jwtqByhZ4vCJSYsx8JT4YSsWaVlPlYGiNyQ62OssG+8xcubfUtnbh8a+l72zZvKyQkyu9TuDnbaR2UD6ICtNaNFyYLRcPdp4QhTVpcD1YwQUnGlNHxSHKqEez3cVX/E8UfObrg6NWA6RJsk32hLQ7PbAYdchLHpxzz2zU45/XzME5k9PgdHtx0793YNXBmkHZFyV1bQ5Ut3ZBEEK3ycZGGfh9P1QrJg+LCaFYy2KK49Yuv0XRmoBFyFAIguDzWVOhJhNFEQ9/cRCiCFwyM1NVKp/VZMA/r5kDq0mPbcVN+C7C/V6Z7B2YCKrkpFxfgVwNaoILGOEUaw63r0gQSbEGABdMl5L+VuyrjqgK7w0l8tg2O9HabZG1vxRra4/UQRSlUKhwhadIyaB8TKTiu+kPmP3G8QBFXWmj75wJ5tmrZILsb1rSaA9ZKA9E6a8WrAU20iIwK1QG3vtZG2fEwhqfb3YXciSpOGdqI7SCGvU67mFXUCOp1spUKgAZvLAmiwhYIuisPgou0Eqmhu6SfTwVmlpAQ0GFNSIi1QEJkQzmldUYRrbe5fJwc/C4ASys6XQCkuULcW2IdtB2h5sXEEIV1phxdqRk0KqWTlz5yma8u6VU9T66PF5+k2Cfz81/VbYXON1ev8JFXw0yAr9z3gqqIrzA7ghfWOOKtRBKx0gtCbwd9GjPi1drjtRie0kTzAYdbuujwAcAOH2CVFjbWtzYJ2mYu8t8g/Fwq+jj06Jh0Alo6XShsgemzYyyRjuuf2Mrpj74NT7bU6n6fUEVa33YCtra5cJ1b2xDeVMnks0ibliQE/b1mSpX4CL5/QwnmJHwrrLmPim+9idH5evtYAYXnEgY9TruZ7O1qGGQ90YbPr+fwZmAAlIxfpqiRW9iWkzESWd/Yjbo8eJVs7F0WjqcHi9ueWcHvuxndVAkDsj+annJtpC2CYIg8AWgqhDXXraYGWoxIznaDJNeB49XRI1CccyVbira9rX4rK06VIvNxxthNujw6/PUm/HnJNmwbJ7ky/qybCkRisI6KdnbatJ3a3FTMk9zYU1WrKmY0PvsUboXJsoaOyGKUqtesKTWQE4dl4y4KCPq2x3Y2o/t5z7ft+5jwYR+UqyxNNCzwqjVgKHfChpKsVaq0l8NkH6LSTYTRNE/BTMcO0qD+6sxItmWHIvQCtrQ7gw7fmGdMIHBBYAySdYVspNJzZhwnFz0O1rThto2B5xuL/Q6Iezit5IcRYCB3enmwo2ZgxBcAPjOUTWdUvsrw6uWCSqsERHocnl4K2dg8YlJscMp1th7dQIQHcFcta9hUt5Q7WBsBTTabAg5UMznyaDhbyp//OQANh1vwGvrj6vev7o2B0QRMOgEPpjh5r8qixFlTXYoFwwbw0ic1dLp9H3n3QtrGhRrIY5ppPACPpgK0ZKwUG4H/a6gvkdtT16viL/JyqfrF+SGNULWytiUaKTHWuB0e1UPjsPB/dWyw9/EzAbfgP1QD9pBXR4vXlx7DOf8Yx3WHpGUgGsOq29BCjaI7KtW0C6XBz9/azsOVbUiOdqEWyd7+DkUCrXx4ZFWJ4cTkzJiYTbo0Gx3dRtsDzWOyoP48alUWFPLieqzxhNBB1GxBvi36A20v1owjHodnl02C5fMlPy87vjPLjy/ugAbjtWjsrlzwFt+D8j3lWkRJlT82htiklYTYeKq0wlBW5PUBBcwfMmg4a//Lo8Xj644BAD46Wl5mosgP1uYB4NOwKbjDfxeHQz23NRRwZO9Gaywtq+iRdXCnK8VVIViLUxhTZm8qab13qjXYckUyeu4P9tBedpikCKQGvWRVpxuL9YdlcY/Z04K7+XMFGH17Q4+XlaipU23PxgrtxUfr2v3K0RpMdoHtPus7QyRCMpg19bCuo5u53hbl4sXd8al+N/7WVHM7RWDHm9Gs3w+BLMeSrCawE7vUFY0kcILACkZFJCU9axQOSo+SrU/mlKxtq+8BV5RWgwIFK8MFKwg2NLpCtutIooiDnCfTSqshYIKa8OQ/RWteLtAxwdCvYFFlkcZ9Yi1+BdKElREF7MLYFyUccCTcSIlg/rSTkNfQJliorTRjo4QF5xvDlRjlWx2WtpoD+vppoStpqbGmPmx0RoVXxwwQe6LVlC2X1aTnqeBxlqYx5qa8ALpONkihhf0TLE2NydRDglw9Cgk4It9VThU1YoYswG3LBqr+f3hEASB+8D1RTvongiJoEp6GmCwvbgRFzy7Hk98JZk3M+WIlu0EbwX1tfS4VP4mAvF4Rdzz3m5sKWpEtNmAf107G8kqxh6hfHoC4W1JI6CwZjLo+KR4p+zpMRTpcLi5YfVgJGSdqLDC2taixiGvSFSiNqGuv1GGwwxGsnIwDHodnrpiJi6bnQWPV8TfvzmKq17bggWPrcaUB7/G+c+sx+3Ld+LvXx/BRzvLeVBUf7BfZQtQJMVaXWvkay5bYFQuyvgKayoUa3wcFX6h8T9bS3G8vkNasFmsfSyQGR+FS2aOAgC8vC60ao3fx0MEFzCyE6OQFmuGyyNy36VwsG6FbBWFtdQwhbVwyrBQXDBd8jj9cn9Vv7WDloRJKuWWIp2uPvv8zccb0O5wIznahOkRCgfRZgM/F48H+Kx5vSIfE6kpevYHoxNt0AlAh9Pj951r9QNjcyA1PmuVzZ2oaumCXidgRojF4NQYSQXn8YrdtsnUf8nR5m4dTmaDbw4arh20mXl627or1vQ6AfFR4ZWOqgpr8rjkWG2b5uMJSAnSgPRdDHYbKCBZ/TDxRDhRR3VrFxo6nNDrBC46IbpDhbVhyOsbi7G9Xoe3NqtvSwyFsiWwW8IKb+kLXczxGUkOXHABI5JZa6gWVyVJ0WakxJghisFvLB0ON/70vwP8325Fv30kagMCAgDfoLTN4VZVxApUnvRFeEG1wl+Nfefsotvl8kYskjDFWlSE8IJOl6fbipXXK4YdTAFSgeAUOSRAa/HK7fHiKdlb7eenj+HF4b5kYYTCmtPtxf/2VOKOd3diTRhj6qYOJz8W00fFR/xcrQEGzXYn7v9oLy5/eROO1rQj0WbCkz+agf/8/GQAkiTf4Y68at7a5eJKRmUraLLNDJNBB6+ovlCsRBRF/PHT/fjqQDVMeh1euXYOLx5GYpTKVtDaCEbaww2W0jWUfdZYK0hytKnPvA9HAjOz42HS61Db5uDXjRMBrlgbxFZQIECxNkQKa4A0Gfzb5dPxxwsn4+xJqRiTbINBJ6DT5cGhqlZ8sa8Kz685hl/+3x4sfXa9JqNxLTBvnSkhEkEZGaytKEgbptcrco+vcMqzYJ4/mhRrvBU09PXf6xXx2voiAMDdZ43nPrJauWXRGADAVwequxVYGL5E0Piw2xIEgavWtkdQvLfYFffdeG2toIGFd64MCzHmCsaCsUmItxpR3+7Eln5qP2d+uzlBTPCZal0UQ3c/qKXD4cbTq47ilnd2AADOmJiqSggQqh20vkNqD9QJ4ecX/YnJoOOLFcr962lh7UhNZO9O5q82OSM2ZHiZIAghx6rs3j8+RLt0Mj+HQ3/fTfbQijUgfICB3emzBwpX+GehdgW17fy3o2VhiBWwq1q6sPm49NtR4+3Yn6ixbtknX8fGp0aHDZAZ6VBhbRhy3SmS/9Dne6t6nZxYE2Z1kRUlmsLc1NgNbzDSvlLkyXIojzXm2RHJDJe3gwaRQj/7bQEqW7qQlRDFE3CK6tWZR1cHCYWwmQ18VUZNMYINPFgKVl8o1mqCFByVrbKR2kE7IijWYi0G3g7RHLDCXtPWBYdbSiwK15bB20GPagsw+HBnOYrqO5BoM+HG0/I0vVctp8oBBoeq/JNLa1u78PSqozjt8dW46z+78PneKvz0zW3496bioNthq9xjkm2q/Am1KNY+3V2Bs59ah/9sLQMAXDE3C9/+chEum5OFUfFRiLUY4PaKfKATDqYqSLAa/QZTOsV3WN6DdtCnVxXg3S2lEATgmWUzsWBssur3+tqRInistav37RkOsNQpNWqIwYK13VOUuzYsRj1XCfSn71FfIooiyplibZBbQTPiLJifl4gxKbYh1+ai0wn46Wl5eO26eVh972Ic+st5WHPvYrx+/Vz84YJJuGr+aIyKj0JFcycue2kjNhzrm/AcRrPdya/hUyIo1jLDKNaa7E64PFJRJzlM0ZzbCPgV1iIX5BgZKpT/3x+rR2mjHTEWAy6bkxVxm6EYnxaDsyelQhSBV77rbgXicEsFUEDd5JkV1rZGKKyVyWq15GgTokKMtZSw4+30eNHa6T+GK46wmBkMo16H8+R00C/29n07qCgqF1m7F9aMeh2fV/S0HdTt8WL5lhIs+ttaPL2qAHanBzOy4/HLcyeoen+oZFA2JkqLtcCosj2wP2BzkuOKOYlWhTC7Dx9V0QrqCy6ID/u6UGNV5uMWyocwWUUyaEsYjzUgfAsxG69bjLqQ9kCA9DthyaCsMKZFsZZgNfJuILYAP9iFtUwVPmvkr6YOKqwNQ2ZkxSE3WoTLI2L5lpJebYsXf4KsuvBUULsrpN8Hl+UOYHABI2IraBDFWDBY5HRggMHh6la89r204vnnS6YgP0N6XWAKTyiqQwwUeRubmsKaHJHOkqb6wm+iKkjBz6DX8TCCSEq6zgipoILgk2MHFmXZ35OVEN6vgAUYbC9u4q2nkehyefD0qgIAwG2Lx4a9cfaG5GgzHzhsOFaP7cWNuPM/u7DgsdV4elUBatscSIkx4/QJKfCKwAOfHsCjKw51+w3tYcEFKm+4rH2ptNGO1jDf0Vsbi3H3e7tR3+7EuNRo/N/Np+CJy2fwQrlyRfFQVeTBVLDgAoavsKZNQfP25hI88630Xf3lkqk4f1qGpvfzQUKYVlCH28MLuykjRBnFFGtHqls1J78OFAVUWOsxrB108wkSYNDS6UKbfB4OZiooIF33/nvzKVj9q8VDfjXeqNchL9mGM/PT8LOFY/DID6bh8ztPw7zcBLR1uXHd61vxf9vK+uzzmK3I6ERrxEXSjDATNDYWS7SZYDKEvr8HUxzXalCssdeEK6y9s1kaG182OyukukYtzFLio50VfD8Zh6ra4PKISLAaVbUFssLazpKmsLYi5fy+q+53Y1HYudS1++9jJPuNUCyV78tf7a9WbYGilro2BzpdHuiE0AEAbA6iddwriiK+OVCNc5/+Dr//eD/q2x3ISbLihZ/Mxie3LQibBqqE+ZgFJoMOdnABgyUbF8lzkg6HG/Xt0rFSq05kbY/VrV0RW82ZEn52iOACRijFWmGI4AJGiorCGlesheiSYl5tDe2hC2upMd07tJQYFMmgrJiopbAmCAI//m6v2C08ZzBQE/jF/dWGgAfpUIYKa8OURRnSTe6dzaWq2rlCwdslgwxmWLHM4xVDqphaFR5rA02kwlowxVgwJgZRrHm9Iv7w8X54vCLOm5KOM/PTQqbwhCJUa0N6BI8SJeyz2I2sLwproQqOagMMOnhhLfRgNZTa0deSEH6Al5dsQ1ZCFJweL7YcV6fOWL6lFFUtXciIs+Dqk8OnSvaWhXI66G/lVsvP9lTC7RUxLzcBz105Cxt+cybeumEe7pVXRv/53XHc9d4uv9ZYtb4sjASbiasFDocoiO0oacLDXxwEANy8aAxW3LWQT8aVsCKdmrZSpgoLNojMCqI8iMSKfVV44NP9AKQWnZ58V2yQ0NDhDGkCzQZRJr1uUAr/g0FarAWj4qPgFYG98vnVWz7dXYEfvbyxR+2+wWAtJ1RY0878PKlF/kRRrDEvveRosyrVDRGaBJsJb/90Pi6eIYUd/PrDvfjb14f7JOSA+6tFaAMFfGqxYBO0WpUpzKy1kS3aeL0if68Wj7XaNkfQv7+qpRPfyuE8P5k/OuL2IjE3NxFzcxLg9Hjxrw1Ffs+x6+z0CMnejInpMYixGNDh9IRd2NLir8ZgSaxKexSXx8uLdFo81gDglLFJSLAa0dDh7PNrTgkzhU+IClmE7UlhbWdpE6745ybc9PYOHK+TuhceungKVv5iES6YnqHqO2KMTQ2vWAu22DiQjGEBBvI8gakc461G7psciRiLkY/tjoZJBu10evh4MVQiKIMtPB+qavX7fYZKBGUky0WxsB5r9vBijsQw3uBawqzGywVHtvs5GtSegP9vbWJaTK+L+72FFZPDtoJScIEqqLA2TJmRKCIt1oz6dkevZNrhfC3MBp+5fWOIdlB+kRuMwpq8z3UhItdr2tSZ4eanSzeBIzVt3Jvi/R1l2F7SBKtJjwcumgwAfAVDa2EtPc7/89kFLlL0cZfLw4sa7EYWbBVGK6EKjsyDJJwaCgDssgIhlGIN8Mm0A1tB2WAqUkuCIAhYOF5Sra1T0Q7a7nDjxTXHAEjFmv5WJJwu71uXywuzQYcfz83GF3edhvdvWYCLZmTCZNBBEATcceZ4/OPHM2DUC/h8bxWu/ddWNNulOHGWJKZWsQYoVwJbuj3X0O7AHe/uhMsj4oJpGfjtefkhB6yTFAOfSLBBZGaQwhr3bVDZCrq3vBn3vLcboghcNX807jl7vKr3BRIXZeTnX6gVOKVJrZbB9InOTLlNoy/aQevbHfj9x/uxrbgJ/9tT0evtAUrFGgUXaGV2TgL0OgHlTZ2aitmDBZvoDZbB93DDYtTjmWUzceeZ4wAAL6wpxN3/3a0qYTIcWlqAWGGttcvdLfCJW4tEWMxUqidEUUSj3Qm3V4QghG8hZaREm6ETJDVIfRAvpf9uK4PHK+KkvMQ+K+Az1dq7m0v9xkhaled6ncDHc+GSxXuSOskUP3WKwkRlcxc8XhEWo05ziI9Rr8N5U6V20M/7OB2UBXOFK/Yxn7VQ849A9pW34LKXNmJbcRMsRh3uOGMc1t23GNctyA2roAwFawUtbbT7eQ9rSWvtT1hhjc1JShu0G+0Dvnvxl/uqQwbj7C1vhtsrzTsjKfXykm0wG3TocHq451uXy/f/Q3qsMcVaGI811iUVKjk+iRdju18X+JhQxTUm8LqhNXxHqRicOYjBBYxRPPAr+LihtrULtW0OCMLQSM0eylBhbZii1wFXnZQNAHhjQ3GPU8LCtYICPuVRqBWj5k7ZY20Qwgu4WWt7d7NWQJkKGn6QNz4tGjpB+hvr2h1o7HDi0S8PAwB+ec4EXlDIS9GmWKsOUbTkqVoR/KFKG+0QRcn/jN34+kKxFirUQa1ijYUXWMO0WjKZdijFmpqWhEWyKmz14dqw8dsA8Mb3RWjocCIv2dYrPxW1LBibhPvPz8cfLpiELb87C49fPj2kN80PZmXhrRtOQozZgK3FjfjhSxux6XgDGjqcMOoFTQl1obwrPF4Rd7+3G1UtXRiTbMNjl00LW0ziK4rVrRGvHeVh2h7Yiq1aj7X3tpXB6fHijIkp+PMlU3tc8BIEIaJnBFudTB4BiaBKZo+WAwxKeh9g8Oy3BbyltECFuXEkWjpd/PsaT4o1zUSbDbxNY9sAqtbcHi/2ljfjX98X4bblO3DpCxtUFeW56maQE0GHE4Ig4FfnTsQTl0+HQSfgsz2VuPq1Lb0aGxxQmQgKyAlz8r0/8Npbp1Kxxq7dHU4PWjpdvCCXZDOr8qwy6HV8/BeopHV7vHhP9ha9qg/Uaowz81MxPjUabQ43liuCw/ZqVJ4DvnZQdYU19cWblCDJoGwxMyfRpsqwP5ALpknpoH3dDsr81cIpgXiRROWC8u6yJogiMCUzFmvvPQP3LpnY49AKQFp8jjLq4fKI3LsMULaCDu51jS32lzba4XR7eeFK6/V2ieyl9/qGItz/0b6gAWY75DbQOTkJEcdtBr2Oe1ezsWpRfQe8ojTPCKUYY2O1UIo1r1fkvt6RFGvhPNbUeO4qF/7iooyau7JyFN/BYPurAZE91pgdwNiU6EFX1w11qLA2jPnx3CyYDTrsq2jhfeBaiWQYy1v6QhXWBlGxxlYdXB4RTQHKKGVrQaTUHotRz1fNjlS34dEVh9BsdyE/PQbXL8jlr2NGoVUtXap8v2pCKMN8hbXwijVWwMtLtvGbRafLwz3OekokxVrkwlrPFWvMY02Nie4pY5NhM+lR2mjHWU+uwye7KoIWgZrtTm4q/ItzJgyImawgCLh50Vj8bOEYVYm4C8Yl44NbFyAjzoLjdR249l9bAUjKMS3qOq5YC5jUPrPqKL4/Vo8oox4vXT0n4mByXGo09DoBzXYXL7SGoiLMAJ+tpqtVz7BizxVzs3nARU9hv6NQn622LWm4wYyFd5U193jBBQCO17Xj3S2+CeRRFUEXkTgmt5pkxFkGxT5gOMBau7f0Y2Gt3eHG+oI6PLXyKH7y6mZMf+gbXPz8Bvzl84NYsa8au8ua8er67kbugbBWUC3tbIQ6rpibjX/feBJiLAZsL2nCD1/c4Df5V8umwgbeSjZFpVIhIz744qDPJy38Nddi1PO2r4rmTkXnhPprdbqs/A8srH17uBbVrV1ItJm42qov0Omkez4gFSC6XB60O9w4JrcJRkoEVcJ+w9uKG0Neo8t7oPYMWlhTUcAKx8ljEpFoM6Gxw4nNKm05alsllVw4WDBXWMWaTZtijf2tJ49J6pO0Tp1O4KowZfLmUGkFTYs1w2rSw+MVUdpo579/rYq1ZSeNxoMXTYYgSIufN7yxrdti9k4eXBC+DZQR6LOmbAMNVZiLFF7Q5nDz1syQhTV5G8G6e1jQnRrF2rhU38Kf1uMJ+CvWZg2BwhqfdzZ3BW2f30f+aqqhwtowJtFmwg9mjQIg3ei14vWKQRMi/T5DvniFurG1DKLHmsmg4wWcwGTQhg5trQUsmODtTSV4f0c5AOCRH0zzM9iPt5r457ECUSjaulzciyxUeEGkwhqXyifbEG02wCTvi9pBRjA8XpG3CYRWrEVoBY0QXgD4ZNrKgqyUAqVesRYXZcSbN56EMSk21Lc7cM9/d+Oq17Z0S7J8ed1xtDncyE+PwYUaTfAHkonpMfj4tlMxKSMWbvnGNkPDYBzwtXAerWnnq4prjtTi2dVSG+xffziVewaGw2LUY5zc5hDJZ60yzOosG1hWtXRGHEi3dLp4IuScXHWDs3CMihBgoFY9MdyYnBkLk16Hxg4nn2j0hMe/Ogy3V+RtG8cUrfI95Ui19NsltVrPOYn7rPVPgMG+8hYsePRbXPOvrXj22wJsLGyA3elBrMWAM/NTcfXJkgpozeHaiL/5MlKs9SsLxiXjo1sXICshCsUNdvz839tVh/0A0v35F//dDUBKjk5SGfLCilqB1162UJsaIYkdUIQ4NXdpSgTl+yAX4QIXhpbLiwE/mpsFs6FvLSEunpGJjDgL6toc+HhXBfaVt0AUpXuRGt8mxvSsOJgMOtS3O3He0+tx7j/W4awn1+KMv6/For+twWmPr8ZR+V6ppRU0mO8wt99I1uavxjDodVzR9MW+yoiv/8/WUpz012/xmw/3hn1diYq2xSSNHmtMsdXTImIwApNBRVEcMuEFgiD4eT+X9rCwBgA3nJqHV6+ZC6tJj++P1ePylzbyQp0oily8EclfjRHYXcHG7aHaQAGlx1ooIYf0uNWkD/nbTu4jxVpukpXPuXpyPCemxcBi1CEjzsLPocEkPc4CQZBSg4O1z+8nfzXVUGFtmHP9qbkAgK8P1Gj2XFEWn0JNPiMp1loGMRUU8A3glGatgM/rIzlaXWvBxDTpJvDNwRoAwJUnZQe9gagNMGCfH2M2wBbQMpmuIioe8K3o5SVZIQgCEmxykbMXPmv17Q545JSawIIjS5QKjGoPhBXWbGHkwr5WUF+Rrr7diQ6nB4IAZCeqG5DMy03El3cvxH1LJsJs0GFjYQPOf+Y7/P3rI+hyeVDb2oU3N0pF5fuWTOxRq8NAkh5nwfu3nIJFcurpmZNSNb0/O8GKaLMBTrcXx+s6UN5k5xOjq+aPxg9mqW+DnSQXk8O1dDncHj5IZ744StJizNDrBLg8YrfidiC7SqU2jdGJVlUTr0hkRvCMqGOrkyOssGY26LkJOUvx0sq24kZ8faAGOgF4ZtksGHQCOpyeiIsBkWCTxYnkr9Zj5slF6cK6jrAmzz3lia8Po7XLjbRYM34waxQe+cFUfH3P6dj9wLl4/fp5+NNFUxAXZUST3RXx/GITs+xBTgQdzoxPi8EHtyxAcrQZh6vbcP9H+1QVwEVRCkCobu3CmBQb/nTxFNWfmRlCdc/uAWoWM3z+nPYeKdYygijWShvs+E72ZL3qpL4PMDIZdPjpaXkAgFe+O45dZdL5P11j4p/ZoMepY6UC+ZGaNhytaUdhXQeK6jtQ0mBHeVMnvKJ071I7VgL6R7EGABdO96WDBmsTZGwvbuTBRB/sKMfGY/VBXyeKok+xFqbgF8mKJpCetkKGgxfW5MJQa6eb2yMMdmENAMbI+3e8rr1XhTUAOHtyGv7v5lOQFmtGQW07fvDiBuwsbUJRfQea7C6YDLqQlieBhFOshSJZ4REY7BrWpKJDKpGlgvYyvMCg13G1Yk/Op6RoMz6+7VS8d9PJQ2JeYtTrkBbjU60FckCDz+ZIhwprw5z89FgsGJsEj1fEvzcVa3qvGl+LRGv4G1ukhJb+hq081LUFL6xFSgRlKFU+iTYTfnNeftDX8Xjr+vBtUXwFNogSkEly2x3usEEBRfX+A49EmyxxDrLaoBY2EE6VCyJKfK2gofdJFEVNraBKjzWmVsuMi9K0kmw26HH7GeOw6peLcGZ+KlweEc+vOYZz/rEO936wF10uL+bkJODMfG1FqsEi2mzAmzfMw84/noMzJmrbZ51O4AWx3WVNuG35TjTbXZieFcdDNtTiCzAInQTFbsAWo463Iysx6HW+lswIPmtsxXOuyhXPSPB0uhBehbUa1BPDDdau0ZMAA1EU8dcVhwAAP543GpMzY/k1iBXGegp7PynWek681cT9azaEmLj2lP0VLVhfUA+dALx/8wL848czcdX8HExMj+GTA4NehzMmSgsDqw7VhNyWKIrcJ0pLcYDQTnqcBS9eNRsGnYBPd1fijQ3FEd/zzuYSrDxYA5Neh2eXzdLkq+MLYApoBeWKEA2KtZYuTUo3BlO3KRVr726V1GqnT0jxa8XqS648aTTioowoqu/A699Li3pa2kAZz/1kNt7+6Ul4+6cn4d2fzcd7N52M9285BR/eego+vm0B/nfHqfj2V4s0jZWCFdZKeWBUzxRrADA/LxFJNhOa7C5sPh5cKVvT2oVbl0vhSWw+8MdP98Pp7l6Ia7a7uOVIXynWRFH0Kdb6srCWylpBpTE/U+Em2UxDIumYLfYX1rWjTL7e9rSwBkiFlU9vPw2TM2JR3+7Ela9sxpMrjwKQfATVhkBMTI+FIEi/z4Z2h6bCmtPtRZuj+wK/z18ttP0KG6c22Z3dFNW+8AJ115lZsq2G2hb5QCZlxKrqzhkolKExSho7nFyYQ8EFkaHC2gjghlOlFbT3tpZpagPwBReErt5HDC+QL3RxUQMfXgD4BhK1AYW1ao0roPmKwtrvlk4KeeEOjLcORSgfMwCwmgy8dTacao37kck3Tq2y+HD7FazlghkSh/NYc7i93ONAa3hBcQP7e3p2089OtOJf183Fy1fPQUacBWWNnXx1+r4lE0+o5EdBEIIWqtTAJPYPf3EIe8tbEG814sWrZmtue1GTDKpseQh1fLnyIIJidnux3ErQB22gys8NmXI0QltBAWAWCzDogWJtxb5q7CpthtWkxy/k1FZm5BvYhq0Vn2KNCmu94exJaQB6F1wUjJfWFgIALpqRGbYwcZb8+asOhi6s1bU54HB7oROCJwoTfctJeYn43dJJAIC/rjiELSEKIABwuLoVf/lCKp7/5vx8zSoF5rFWqRi/iKKoWMzQoljr5N5sWnyx2LiVjWkcbg/+b3vfhxYEYjMbcO0pkhqOtazNyNau8og2G7BwfAoWjk/BgnHJOHlMEublJmJOTiJmjU7A9Kx4xGo03lcGegGAVwQvtvRGsWZQpIN+sbd7OqjD7cEt7+xAXZsD+ekx+Oru05EcbUJhXQde+767FyNTq2XEWcJ6zIYzog+krt0Bu9MDnaCtfTYSvlbQDr820MFOBGWMleckm483wun2Qq8T+KJjT2GdFWflp8Lh9vLvXK2/GiCd36yYu6+ihQsFxqWEvvdHmfSwycXKYB5paoQczIZGFH3zU0CywWEqNjWtoIA0F1z+s/lYOoQtZrSQEWKsztpA85Jtmq85IxEqrI0AzsxPxehEK1o6Xfh4V4Xq91WrUHUpq/+BeLwiWuUizGAZUfNW0IA2NLWJoIycJCuuX5CLG07NxWWzR4V8ndpW0GoeOx/8As7VNiGKAnanm28jL4kp1npfWAun5OMea47QijW7IjghKsyAKFh4gRZ/tVAIgoDzpqZj1S8X4ebTx8CgE3DB9AycPCapx9s80WArSm1dbggC8I8fz+zRQJIV1ooaOkIW5H0mvaG3ryYZ1OXxYndZMwBgbk6i5n0NhtKjJ1hxQYufxnBjdk48AOBwdZumxRan24snvpYSkX++cAxXnjAj394kgza0O/hENNyqNRGZ60/Nhdmgw+6yZmwKU0DRwvG6dqzYL02gbl08NuxrF01MgUEn8Pa1YDBlR0Zc1IAEyhDADafm4pKZmXB7Rdz+7q6gC3edTg/ufHcXnG4pnflG2U5ECz4jbN81v6XTBafcJqim1SpTMcmraetBeEGs3Aoqj2m+2l+Nxg4n0mMtOKuf1evXLZB+fwAgCMC0IdI+xcbDjR1OON1eNDmkcC+TXsdVhj3lAtYOesC/HVQURTz46QHsKm1GXJQR/7xmDtLjLLzI++y3BTyIgaG2PVU55o20gFDa4LveqFVVqSEv2QZBkM7vxg7nkAkuYCiTQQGpYG3og+utzWzAK9fO9Qtwm62x24AtAn99oAZOjxcWoy7icQuXDMoKZQlhFGtGvY7PR5VzpcYOScEmCD6RQiRiLEacOi6510FbQ4VRijGzkv2VUmGtp8q8kQaNZkYAep2A6+SLn5YVbF+CU+jiU0KYVlBly+DgFdaCK9a0muEKgoA/XTwFD140JazySavHWqiiZUYEnzWmVouLMnLVYF8U1qrDrAyrSQXtkOXZFqMu7M0mIUhBlivW+qBFw2Y24P6lk7D/oSV4dtmsXm/vRGJyhm8Qf+cZ4zS3kzJSYsxIiTFDFKUCTDDUmPSyol64wtqhqlZ0uiQD9HDmtVpg53Cny9MtfdbrFfnAbKR5rAHS5CIjzgKPV8Te8hbV71u+pQQlDXakxJhx0+lj+OPsOzta2/NW0KNyUS47Maqb7yShjeRoM5bNywYAvLimsE+2+c91xyGKwFn5qchPDz/AjrUYMX+MVCD/NkQ7KEsEHSoT0JGAIAh49IfTkJ8eg/p2B25dvgMOt3+K+MNfHERBbTtSYsz4249m9EjpHczfjI3B4q1GVUnXTPEjpYJqbwVVetWKoshDC5adlN0nhYVwJEebccVc6fc3JtkWMYV7oIiPMsIgj8saOpyo75L+f3ZiVK+LA/PzkpAcbUKz3YWNhb5i/vItpXhvWxl0AvDslbP4wukPZo3CSXmJ6HJ58efPDvptiynWchLDL7KyMa/D7fVb1A1GX3jJBcNi1PPxT2Fdx5AJLmAEdoD0pg00EL1Omhc9+aMZuH5Brma7FbYIvGKftGAzJjk64nnIk0HbuhfWmlRaD7HCmdJnjS20JtlM/X59GKr4vDH9x+oHKshfTQsj8+wZgVwxNwvRZgOO1bZjfYE63xVtirXuKiY2mbWZ9H26QqQF7rEWEF6g5m/rCUza3Gx3hQx0ABAxbTVD4S8SjGDGrn3ZChq8sCaHF4QprHW6WCJo+Ikxu/G1dLq4z0FfKNYCsRj1w2Y1SS2TM2NxwbQMLJuXjbvPntCrbUVqB/UNIkP/jrJUtIKyNtDZOQl9ZuRqMep5ilSgz1qjXVsq8HCE+YOobQdt6XTh2W8LAAC/OHuCX/Frgty6eaymvcethwVyUW5CKrWB9gU/lxW73x+rxx5ZDdpTqlu68NEuKQ37tjPCq9UYrB01lM8aBRcMDlaTAf+8Zg5iLQbsKm3GXz73FTW+2l/FC1BPXTGjx9dG5tXT5nDzBVY25lHbes8Ua3VtDr4Ioi0VVHqt3enBztJmbC1qhF4nYNm8/msDVXLnmeOweGIK7jpr/IB8nhp0ilCq+nYH6uThZW/81Rh6naBoB5XSQbcXN+Khzw4AAO5bks9DmQCpyPvwpVNh0An45mANVh/2XSeYuiwngi2IVTG3iDTuLemHRFCGMhmUK9aGSGEtxmL0+831RwLzZXOy8KeLp2hWHjPFGgu5U6NU9yWDhlasRSysRXefK7GuppE6HgRCB37tk1tBh4rydqhDhbURQozFiMvnSImAb2woUvWe6jAG+4xwKqlmngg6OP5qQJhWUKbG66XXQCBRJj2v+h8PE2BQHUExl8GMd0MYrzNFXJ5ikJAQZBVGK+G839SEFzDFWrjgAgCIj/L5HLR2uiCKoi+MYQiZeZ6I6HUCXrhqNh67bHqvi4qRkkHVtD34WkHtIV/T18EFjMwQ0na2OploNY3YNjTmh7KzpFnV619aW4gmuwvjUqNxxVz/dNncZCv0OgFtDrefWbgWjsiqyAnpVFjrC7ISrLhkpmRb8OLaY73a1mvrj8PlEXGS7PGkBlZY21bchJYgC28UXDB45CTZ8MyVsyAIwDubS/H+9jJUNHfi1x/sBQDcvGgMFo5PibCV0Ch9YlkgktawmASrkdtJiKJ0X1PbogVIYzG2D0+tPAJAUltq8WnrDamxFrx5w0n8NzhU8Pms+RRrfbWYecG0TABSa19Zox23vCOFFVwwPQO3LBrT7fUT0mJwo5yi+uD/DqBLXpjlC8cR9ksQBNULyqXyNkdHUMH1BGUyKF9sHEILBnmKBfi+VKz1lkAjfHWFNd/5Gwibc4ZrBQV889YGRXGuTkMi6HDF137vG8O12F28jZhaQdUxMmcUI5TrF+RCEIA1R+pwvC6yF05NmCILg12gWjpdcAfEbLPVg9hBagMFwrWCavfsUIsv3jp0O2gkjzemWAuMq2cUs8Jasu9G1BeKtXBKOu6xFkaxxuT4kQprJoMO0bLipcnuVJ0CRQwskyMkg/oUa2E81hSrYMHUTKIoYntJIwConrSrJZRXoZZY9eEKCzDYXdYUUWVW0dyJ1+UFmd+el9+tVcJs0PMW7p76rLH3sSAEovfcungMBEGa6Bb0MLG1qcPJ0xRvValWAyRlxMS0GHi8ItYere32PPNYI8Xa4HDGxFTcc5akaP79J/vx87e2o7XLjRlZcfjVORN7vf3Aa2+tRk9LQRC48g2QxnJa1cxsHzYck1oTrzo5R9P7hyOpimTQeqZY62FgVCAn5SUiOdqMlk4XfvjSRtS3S2EFf7t8esiW4rvPGo/0WCls6sU10gKAlrZNbkcTxOdZSb8q1hTJoGwBcago1gDfnAQYWuPr1BizX7FcjQ2IUnEZCOucimQ9lGiTtuHXCto+clPiGaywVt/u4BYBB6oktVpWQtSgimROJKiwNoLITbbhTNlv6a2NxRFfH85vixEXZQS7X7LVAgaT98YPYmGNTZztTg/aZTVVl8vDL8B93QoKRPZZ83hFfhEP9fmZEcILfK2gvptkbz3WRFHkhbxg+8VuVuEUa77CWmSPJCbXbrK7+N+THmsZEhHlhMRkRSuoNyCa3OsVuRdDOMVaRrwFggB0ubxB1ZTlTZKHjkEnYGZ2fN/tPBSKtQDlJ/OPHMmFtSmZsTDqBdS3O7nfVSie/PoInG4v5ucl4qxJwX1UxrMAgx4kg4qiiCNy4WcCJYL2GeNSY7BkstSexRI9tfLWpmLYnR5MzojF4gnaVEzsXFkZJB2UF9aG0ERvpHHnmeNwVn4qnG4vDla1ItpswLNXzuoT645An1hfK6j6MZcyLTa1B2M15cLl6EQrFo5L1ryN4UaKX2GtbxVrep2ApdPS+fbjoox45Zq5YceDNrMBD1w0GQDw8rrj2FfewscJavaLt/UFUTApYe2l/VFYYoq1/ZWtfG4xlLwjWTIoMLQKa4Ig+KnWVCnWWHhBEI+1FhXhBUBwEQJT1I7kMWGC1QiLUbr2s+v2fmoD1QwV1kYYN5wqya4/2FGO1jAFki6XhxfGwvla6HUCL5wFeorxwlqEfvf+xGY28HhmNplmkl+zQdcvoQqRCmsN7Q54vCJ0gs8vIJB0biIZPNGwSA4vUEq8g/kGaKG1y8090sIp1rpcXr/UJyUsYTCSYg3w3fya7U4uNR7dD6uJRM/JS7bBZNDB7vTw74hR1+6AyyNCrxOQFmYwYjbo+Sp5RZAAA9YGOiUzts+LqqFSjmh1UvKgm5IpDZZ2lYX2Wdt8vAEf75bSpH+3dFJI5cF4WWnWE2VUXZsDLZ0u6ATfJIXoG5gn2qd7KrmvmVo6HG68KS/C3bp4rGYj+7MnS+2g647Wwen23TPcHi//TVIr6OCh0wl46sczMUYeRzx86dQ+K7IE+sTyFGYNE9csRXEi3D0mFMoFwp/MH91n/p0nMimKLo56uTbRF4FRjAumSemgOgF47spZqsZ0509Nx8LxyXB6vLjjPzvx/+zdd3xT9foH8E+S7k0LXcxC2ZYtUxmycTCcCIgTJ+55r/pTVHDvK3hFcA+uCiKiyBBBlgzZG9lQCpTunZzfH09OTtom7UmapOvzfr14tbQZp+3JyTnP9xmAnBuH6RhiU9EANVVOYYldsM57gTV1Hw8P8qu2gW2O1NRSUEBbvDUZDbqOPY0q6LGmBjUbhFaWseZgeEGO68enusZgMCAxsnRP5J0cXOAyBtbqmX7JMWgTF4bcIjPmbTzu9HZqtDrY34SIoIrf3Jz19srQOaHF29SVTrUUIdVu2qk7E68qk9So4sBaql22jLPpM+pUrbwic7lhAdkFxbY3FfvhBWp6c2Z+sdPAV0XUFWVnU7vsT3KclYO6krHWwG7whTrl1JMneFR1fiYj2sY57rOm9kiKjwiqdIqSGuByNBnUW2WggPY6KlcKytVJAPZ91soH1hRFwefrjmDSxxugKMBVnRPRuYKMwtZx7mesqdlqLWJCdU0MJP06NYnCpa0bwmxR8N9V/7h03282HkdGXjFaxIRglPWC2RVdmkShYVgAsgtKsPFIuu3rpzMLYLYoCDAZEVePg9s1QWSwPxbdfwmWPtQfY7p6rh+YbcKcrRS08inz5R/DLrDmRsaaukAYYDLi2u5NKrl1/aC+5+0+nY1iiwEmo6FUZmBV9UyKxnNXdsCsid3RX2eGq8FgwLTRFyHAZLQrA9UX4LVValRQCqpmq0WHBnhlQmvDsADbwjNQs8pAAaBdQgQMBml9E1nN12NlqRlrLWJCdGXKaqWg5f/eF6z7QGRwJRlrDrIcz/KcEED5vsQ7T0nGGvur6cfAWj1jMBhwc1/JWvtk7RHbRMay7MtAKws+RVtXjMpmrKmBterssQaUXqEDKm7Q7wkt7TLWypbP2T9/RSeKwQEmW0AytUyfNfXEIyY0ABF2JwmRwf5QF2QvVNJvwpHKfi9+JqMtE81ZOag6vCA0UE/Gmmx7Rl6RVyaCkmc4G2Dgylj5JtY+SiczymfMqBNBe7Tw7OACQJtOd7pMYM2d7Im6SJsMmlHq63lFJXh43jY88+MuFJsVjOgYj+njUip8LLU/yv4z2S5PBt1v66/GMlBvuGdgMgDg203Hyw3ycaaoxILZqyUQd+eAVm4NQjEaDbisnZSD2k8HVctAGzcIZhZRDRAS4GcLjHtKfGTpPrFn1OEFLvS1tS+nc6cfrtpa4OrujRFTj6f92VPf83adkvfzxlFBHh3gYzAYcHO/JAzrGO/S/ZIahpYacKA3s8wWWKugFPRYupxfeqvs3GAwlMq0blKDykABOUf75JaemHPzxdW9KeWMuCgeE3o1w79Gtdd1e2c91krMFtuCf4PKpoJakxDSmbFWjv05c05hiS1BhBlr+jGwVg+N7doYUSH+OHEhv9TJrj1Xmvs3cLJipPVYq96Gh7YBBlmle314eiKoqnFUMPxNBhSWWHDawYS8M1n6Vm5t2TZl+kP9o07PbFg6CGUyGmzNJd0pB9UT8KtsgEG+zuEFgJbCfyGvSPcUKPK99tZU/d1lAmunbNOvKj+JVG9TthQ0u6DYlq3k6YmggBb0S80qKDVcRQ0uuHKRVxd1s/7O95zOsr12D5/LxbgP1mL+3ydhMhrw71HtMXNit0rLclo2CoXRIMeGssNiKrNfnQjKwQVe0btlNLo1i0JRiQVz/jyi6z4L/j6J05kFiA0PxLhu7mcyDbZOB12254wt4HrC2tOvpl2AkufYMtYyZWiN7ZjrwoWrfSaVOxlrA9s2wpIH+2Pa6Itcvm9dpS40l1gXfZvXoNLAewYl20rDkzyYsWbLgvPiz2ofWKtpGWsAMKBNI1vrh5ok0M+El8am2N4nKqNmm+UVmW2tZwDtehPQM7xArbLiVNCy7PsS7z6VBUWRfpkNuTChGwNr9VBwgAnjezYDAMy1Tnory5WsLmcZa5n58v9qLwW1lpqoKxK2wJaXDqB+JqOtj8FhB5NB1ZXbyn63ZZv/qtSJoI6CUHpW75yxZSlWGFiTv6Wz/ny5bg4vcGUKFPmWs8mgapBMz0mks1LQv49lQFGkz5I7zakr0zAsEP4mAywKcCa7/ElUfe6xBsjFb1xEIEosCnaczMSSXam46r0/sTc1Gw3DAvHl7b1wR/+WukrmZTKoHJNcnQy6P80aWItnxpo3GAwGW9baF+uPlroIccRsUTDrDxl2cPulSQj0c78899LWDRHgZ8Tx9HxbmbCasdaEE0HrLPvJ5tmFJSgoloUNV465jasYWDMYDGgbH+7RjKzarlFY6d9jTTrnCvI3YdbE7hjfsxlusF6jVMZRI/qyvDkRVKVOBgV4XPOmsEA/BFpLRs9la39zdXheeJBfpa1J1ODchbxiWCwK8opKbMPt6n1gzdZjrcA2uKAmBmRrMr7b1FOTejeHyWjA+n/Sy5V4AXZ9yHRkddky1nJLn6zbeqxVcymompWi1tCnqoEtL2WsAUBSQ1m9Onyu/AWmnmmrgBZYK1vGpgbWkhyMSHfUlFMvPdtVecaa68MLjqfnebWxLFVNO2tg7WRGPjLztNe4Wgqqpz+Lmplyssy+vMna26uHF/qrAVKKFu/gdZTG1UkAcuHZtalkrT37407c+flmZBeWoEfzBvj5/kvQu2WMS4+XbFcOqpeiKLZAHEtBveeydrFoFx+OnMISfL7uSIW3XbIrFf+cy0VksD9u7NW8Ss8bEuCHfq1kP1Kng6pDFDi4oO5Sz1/yisy213d4kJ9LA2riI4Ns7S3qe3axp5R9z6tpzew7JkZixrgU3e/Ntl69FZzzenMiqKpUxhozcb3GYDDYsqfO2pWDZuicCGp/G7NFQWZ+sW2hNdjfpGtgRl2m9VjLt/VXu6gx+6u5goG1eioxKhgjLpIeCI6y1s7oyF5SRYeqmUdleqxZVxCqu1lmbJkea7ax717qsQZIWRSglW3a08bOV3zikGA3GdTe4fOOS0EBbfWuSj3WKgysyd/SWWDNnYy1bcczAKgNYGtWY1WStHo1c2BPqhaEt2Ws6TiJbGJXCmrff2uzbXCB58tAVQllphzlFJbYhmzU934aANCteRQAYK+1HPPWfkn4ekpvtzJE2rgxwOBUZgFyCkvgbzKwFNyLjEYD7h4oE0LnrDliK/21l1VQjJX70vDOsgMAgMl9mnvkQkOdDrrc2npCzVxtysyOOivI32TrdaS+x7t6vPU3GTGxd3Nc2rohkjkt2COCA0wIt3tN1/bFzBgdi8lH073fw7eml4LWJQ2tx5HzdoG1C7n6h+UF+BltSQLnc4tKLbR6Y6BdbWLfY03NWEthfzWX1O/QbD13a78W+Hn7aSzYegpPjGhXqrmrS6WgDhpBAlrGWnWPnVZLD9QeH64EDd2V1ND5ZFA9ASxACwiUDaxpGWvOS0HPu1MKquNvrmWsOS4lynMjY02desrBBTVX+4QInMyQngu9W8ZAURSXhheoq2DZhSXIyi9BZIg/SswW/G1tmu+NwQWqxmWmHKmrk6EBJoTW89VJAOjbqiEAec2+ek0nXNEp0e3Ham3tkXbAhYw1tb9aUsNQXVPByH2XpyTgjd/241h6Hr7ZeAyjUhLw1+F0bDqSjo1HLmBvahbUeTvB/ibc3C/JI887uF0c/o2d+Pt4Bs7lFNpKQb3VTJxqhoTIYFzIK8a2ExkA3CvnZH80z2sUHohsa+lbTeqx5g41Yy0zvxglZku5MsBis8X23u/NIGLzmBCEBJhQVGKp9cHKmq6RtZTTfjKomsgRpSNjDZA2IdkFJUjPLbINQuBCq3aunltktg2V4uAC1/Cqoh7r1qwBOjWJxPYTmfhqwzFMHdza9j21D5ieUlBHGWuKoiDLxQOdt6glBGnZhVAUpdoDa3qfP0FdObAbXpCZV4wL1oBlhT3W3CgFPaOjFDTCGljLynecsZbnxvACFU9Gaq4OiRFYtueMrWw8q0DrSaEnsBYS4Ifo0ACk5xbhREYeIkMisTc1G3lFZoQH+aFNrPdKABPLvI7UISb1vQxUdVHjSHx9R280jQ6ucm+Y1rFaxpqiKLpWf9WyUZaBep+fyYi7BrTCv+bvwIs/78HzP+0ud5vmMSG4uEU0JvZubns/qar4yCCkNI7EjpOZ+HVnqu38oilLpuq0xKgg7D6d5XbGGnlHw/BA/HMuFwYotX6ASFSwPwwGQFGkZ1bZ9/WTF/JhtigI8jd6df/zNxnxyS09kVdUUu3XPHWdo8mgaimo3tZD0aEBOHwuF+m5hRxcYCfI32Q7Vwfkd83jtmsYWKvHDAYDbu2XhAe/3YrP1x/FnQNaIcDPCIvFteBTAweTKPOLzSiyTuGr9h5r1oNCRl4xzuYUak10vdizo6U1sHY8PQ9FJRZbJkZ+kdmWoVVZ0NI+Y029SFXLQGPDAx1m27gbWCssMdtS6fUML3CasVboeimoimVgNVeHBAl6qKWgahlodGiA7p45TRoEIz23CCcv5KNjYiQ2HZEy0G7NGsBo9F76vW26rjXDLo2DC8rp08q1XmrOqJNBM/PlWKvnd7yPgTWfurp7Y/zn94M4mZEPo0GyUS9uEW3918BrLRIGt4/FjpOZ+Mza3y0kwOSxwB3VTOqx94i1x5U322+QfmoAoUEgbI3gays/kxGRwf7IyCtGem5RueCIOrigWXSI18v8eiZ5p1csleY4sCbXJA10th5S33vO5RTZqpkYWBOJUUG2a8iUxhH1vjzWVbX7iEpVNiolAbHhgUjLLsQvO08DkJrzEosCg0HfgSbaQfNQ9SDnbzLoyl7ypshgfwRY08N3nZTAQFSIP4L8vbddjcIDERboB4sCHLO+sQPagIBg/9J9Lhyxb/6rBuNsE0EdlIECjsdI65FmzSAI8DNW2KNA3WZnPdbyiq2loIE6MtZCmbFWW7S3DjDYfyYHxWaLS2WgqrKTQbXBBd4rA7V/XrUcxNZPg82wPS7I32Qr6dY7GZQZa74V6GfCd3f3wVd39MK2/xuGn++/FM9d1RGXd0rwauBjSHvps6aWlzRt4P0LXapeZbPfmflQM6h/h4ZBSiW3rB0qWlA+Zl2MbhbNhdu6oqGtFNSux5qasaYzW9B+mqw2JZ7HJ0CbDAqwDNQdDKzVcwF+0hwWkIbGgFYS2DAsUNeYcjVAkltkRkGxZCzZ91er7pNng8FgCxBuPyHNGL1ZBqo+p1oO+s9Z7QLTvr9aZb8X++a/ahmbWlqa5CS7K8ba7+5CruOMMmdS7TIUK9ouW4+1wooz1kJ1ZKyFBpjgb9KeixlrNVfTBiEItfYP+edsLk5aeyS5E1hTg3KbrYG17l7srwbYTTmyvoZsaf9hPInyBnUyqJ4+a2aLgoNp6kRQNif3lYTIYPRt1dCnw2I6JkbYFosA1PoSNKqcWoavYsZazaA22m9SR9Yyox1UzajUhW0u3NYd6vCCc9nlkzn0DC8ASgdjOSW+tES78/qOiQysuYqBNcKNvZohwGTEtuMZ2HLsgkuDCwDJYvKzlnKpqwaZ+TVjcIFKPWDusE458cUJnqM+a2rQMk5ntoytHNSabXNYd8aaa6WgegcqVDYV1JUeawaDodTqEgNrNZfRaEA7a9bantNZOGXdX1wZK28/GfRkRj5OZxbAZDSgS9Moj2+vPbVXYUZeMfKKSmxp/94sBa/PWlsDa/t1TAY9dDYHBcVSKs/hJXWbwWDA4Paxtv9zcEHdlxBZ+v2BGSE1w3U9muKjSV0xvKmlujfFI2xBkrzy571HzzOwVtc4LAXNl7992d7NzqjD+s6Xylhj4B8ovSCS0oSBNVcxsEZoGBaIq7rIJLi5a47Yspf0TnAyGAy2rDV1xSgz37W0XG+LtQXWMgAA8T64qK4osKY3aKmu8KuTQY+cVyeCOj5JiLGmSF/IK4LFoj/NX28wVc1Yy3ISWMt1YSoooPVDiArxR6TOlSaqHh3sAmtqjzWXMtasjfFPZOTZ+qt1TIzQ1Y+vKiKC/G0lzKcyCngS5WVqSedBHaWgP207BQDo2yoGJi/22aOaYbC1HBRgxlp9kFgmsObOVFDyvAA/Iwa2aYSg6u3S4jHqeW96jvOMNQby6w41sHbWvhTUWqWj9zpCKwXl8IKy1Iy1BiH+SNQxwJBKY2CNAAC39GsBAFi847RtglN8pP6DjJqKrR7cbGm5NSRjTc1OUaeRebsUFJBG3gDwj11gzRa01Hmwsp8MqihKpRlrahq02aIgy8mAAUdSdUwEBSoeXqAoCvKL9A8vkO2V/aa2j3yvD9Q+a7tPZ+GEtZwz0Z1S0Av5Whmol/urqWzloBn57KfhZcm2jLVsKIrz4L7FomD+3ycBAGO7NvbJtlH16tMyxrbowgvdui+uzDkkj7nkDWqW0oUyGWuKomiloDze1BlqG4/sghJb+yG1Skpvxpqa5Xg2u9CW+cbAmuiZFI3EyCBcd3HTam/lVBsxsEYApI66Z1I0zBYFP1gvdlwJPjUIlYCLmoqdUcNKQctmp1R7KajObBn7yaDpuUW2EszmThqxBvppQxFcKQdN1ZlJZ+ux5iBjrcisoMSaJadneAGgZayxDKzma69OBrXLWHMl60QtG72QV4zVB84BAHo0980ULTVAfSojn/00vCw5NgwGgyyunHOQQaDadPQCTlzIR1igH4Z1iPfhFlJ1CfI34eGhbXBp64a4tHXD6t4c8rJAP5Ot0XhogMnhJHOiqnLWAuVsTiHyiswwGoAmDRhYqysigv1s/ZnVv7kaVHV1Kujhc7mwKIDBoGWx1Xex4UFY8+RleGpk++relFqJgTWyubVfEgDJdgJcS9svOxnU1mOthpT3lV0p9UXGmppVdja70JbhpbeXmUorBc23lYEmRgYhuIJSy+gw541cnTmjc7siKshYU7PVACBE58RVdR9Tm+lSzdU2PhwGg4wnV1f4XCkFjQz2twVm1WBzDy8PLlCpGWtH0/NsrwtmT3hHkL8JzazZAQfSnA8wmP/3CQDAiIviKzyeUd1y+6Ut8fltvbxeAk41g7o4yDJQ8pay1x+qY9b+agmRwQjw4+VuXWEwGGyD2s5lF6KwxGzr7xwVrLfHmtyu2CzXuzGhAfDTMayvvmCmmvu4F5HN0A5xpTJQ9AZ/gPLjrrVS0JqxAlC2UbkrP5u7IoL8bb0AjpyTN3i1FFXvSaZ9xtph62M4KwNVVTR63Bm1h1tl26UGRgqKLSg2l258m2ftrxbgZ9T9BjWlf0s8MLg1JvZupntbqXqEBPjZsjDl/ybdE5hU9oG4Jg2CfXaxpT7vDutUYD+jQXfJALlOHWBw0MkAg4JiMxZtPw0AGMcyUKI6S10cZIYweYuzjDUOLqi7GobL3/xcTiEyrdebRoN2jVKZ6DLZaY3Yc5c8hIE1sjEZDZjcp4Xt/65kdUWX6XGgDS+oKRlrZUtBfXOS17Kh2mctBxaLYptI6HLGWkYBjlTSX00V42JgzZXtCrN70ypbDprrwkRQVZMGIXhoaBvbhB6q2dQ+a4Bkgbm6qmVfjuGr/mqA9jradiIDgDS/NbJZvte0tg4w2H/Gccbair1pyC4oQWJkEHq3jPHlphGRD6nHXl+036D6yVnG2tF0BtbqKvvJoBfytNZDes/r7NvmAAz8k+cwsEalXHdxUzQI8UdksL+tJ5IeZaeCZuTVtB5r2kHTZDSgYahvDqL2fdbS84psaceNdAaS1EBXfrHZFhRIqqQfmasZa+p2GQyVl8f5m4wItpZ5li0HVUtBQ1niU2d1sAusuVIGqrLPiO3hw8CaWgqqBoN9FVivr9SMtQNOJoP+sEX6eI7u2pgBTqI6TA2c9/RR2T/VP/bnvPYDc45Z26c0c9KTmGovLbBWZNdfzbUqBLVtDqD/moyoMrwCplIig/3x09RLYLYoLvVAsa0Y5ZUJrNWQjLWYsEAYDYBFkeCRry7mkhppgTW1v1rDsADd/R6C/E2IDg1Aem4RNh5JB1B5xpoa5DxfQeNwe9p2BcJfRwlnRLAf8ovN5TLW8tzIWKPaRR1gAMClwLvtPnbBuO4+GlxQ9nkB9lfztjbWjLUDDkpB03OLsHJfGgCWgRLVdSNTErD9uWG2/qxEnqZefxSZLcgpLLFNr2fGWt1ln7Fmaz3k4vVmdGiArVyYi63kKcxYo3KaNAhxeUqjulKgBnPU4QVRNSRjzWQ0INqapebLJrr2GWtquaWrz6+WUhQUW6yPWfFJglYKWqjr8W0DFXRul3rSklUmYy2vmIG1uq59FTPW1GBceKAf2saHV3Jrz4mLCIJ91SrT/r2rVSOZDJqeW4TzOaWPQ4u2n0KJRcFFjSNsJaNEVHcxqEbeFBLghyB/uZy9kKudlx63BtbUYTpUd6jThs/lFCEjT2095FrGmv0UUGaskacwsEYeUTZjzRZYq0ENwtUsFV9MBFW1UjPWzuYiNbPQredPsOt7ZjQATSs5SVADiGUbuTqTmuVa3ze1OWi5jLVC+T+nvdVd8RFBtnHmTdzIWOvXqiE6JETg1kuSYPJhCWCAn7HUiRMb1XpXcIDJtn+UzVpTy0DHdm3i8+0iIqK6J8Z23ivn2TmFJThnXehnxlrdoy6OnssuREa++xlrKmaskacwsEYe0cDWPLQYxdZ0bKDm9FgDtANnnA8PoE2jQ2A0ANmFJdh5KtO6Ha4G1rQARmJUMAL9Ks4IiykT5KzMmSz3MtbKBtbymbFW5xkMBoxKSUB4oJ9bwwciQ/yx+IFL8dDQNl7Yuool2mXYsRTU+9rEWstB7QYY/HM2B1uPZ8BkNOCqzonVtWlERFSHNAiV81L1vPeYtcQvOjTAds5KdUfp4QXWjLVgFzPW7BdbmbFGHsLAGnmEOhW0yGzBqYx829cjdI4+9oUW1vLWynqUeVKgn8k2CXH9ofMAXM9Ys88kS9Kx7bZGrjp7rJ3OdDdjrXQpqG0qaGDN+ZuT5700NgVbnh1aasJnbZAYpe3fDKx5X3KcdYCBXcba/L8lW+3S1g1ZjktERB5hq9SwnvceS5fBBZVVeFDtVKrHmrX8t4GLGWulSkF5PkIewitg8ojgABOC/I0oKLbg8Dl5QwsP8oOfjmb4vjL1smR0SIzAFZ0SfPq8SQ1DcSw9D/9Yfy/xka4dwO0DAq4E1s5bJyQZDBWX3B21Tk7SW9oX4aQUVJ0KGuLPjLW6Ts+Qi5om0S7zkydR3qdmrO23ZqxZLIotsDaWQwuIiMhDokNKZ6ypTembM7BWJ6k91i7kFeOctY9r1UpB2R6EPKP2XR1RjaVmramBNVcPct4WExaI63o09XkPsLLBMNeHF2gBgRY6hkqobxaFJRbbpE5nFEXBvlS58G2js5G4bXhBfpnhBbaMNQbWqOZJsC8F5UmU17W2ZqwdtGasbTp6AScu5CMs0A/DOsRX56YREVEdUra3MCeC1m0NQgJsfXr/sV1zulYKql4rBfubEMoWNuQhDKyRx0SHlQmsuVjvXle1bFTVwJprGWshASYE+slLO72SAQZp2YXIKiiByWgot53OhAc6GV5QxB5rVHM1tsv8VFc7yXtaNZLA2rmcIqTnFmH+3ycAACMvikcwjxFEROQh0WqPtdzSPdY4EbRuMhoNtsCYWnXTwMXAWsuGMr28TVxYpZU9RHpVa2Bt1apVuPLKK5GYmAiDwYAFCxbYvldcXIwnnngCKSkpCA0NRWJiIm666SacOnWq1GOkp6djwoQJiIiIQFRUFG677Tbk5OSAfK9BmYy1mjS4oDqVDYa502NNPebr6Q9nMBhsvQMqC6yp2WotYkIqHYqgsvVYK3SSscapoFQDqT3hGoYF6N7XyX2hgX628vJdpzKxaPtpAMDYbiwDJSIiz1Ez1tJtGWtyHdJcR5UH1U7qdY5Fkf+7WiXVLCYEP97bD/+9qYenN43qsWoNrOXm5qJz5874z3/+U+57eXl52LJlC5555hls2bIFP/zwA/bt24errrqq1O0mTJiAXbt2YenSpVi0aBFWrVqFKVOm+OpHIDvq6oEtsFbDSkGri31gLcDP6PLBP9DPhAcGt8ZNfZqjhc60djV7sLLAmtr/qG28vjJQwPlU0Lwi+T8z1qgm6pgYgamXJeP5qy6q7k2pN1rHStbarD8OIbugBImRQeidFFPNW0VERHWJmrF2PrcIxWYLTmXIUC6WgtZdZXvlutN+qFOTKJeriIgqUq2pJSNHjsTIkSMdfi8yMhJLly4t9bX3338fPXv2xLFjx9CsWTPs2bMHv/76KzZu3IgePSTi/N5772HUqFF4/fXXkZiY6PWfgTRqxtpJ61TQKGasAZCm6QF+RhSVWBAfEeRWyvGDQ9q4dPuy/SacUQNrrWNdCazJYSPLSSloKDPWqAYyGAx4ZFjb6t6MeqVNXDh+33cWaw7KROTRXRvDaGTJBREReY56znshtwgnL+TDbFEQ5G/kBPA6TJ0MqnK1xxqRN9SqK+DMzEwYDAZERUUBANatW4eoqChbUA0AhgwZAqPRiA0bNmDs2LEOH6ewsBCFhYW2/2dlZQGQ8tPi4mKH96lN1J/B1z9LZJBkKinWtNyIQFOd+H16QovoEOxPy0FseIBPfidR1uDX2az8Cp9vb6rs+60aBuverhB/uTDOzi8q9ZrJLZRAW6DJ9/se1Q/VdWwj9yTFlJ40fGVKXK3623F/I1/hvka+VNf2t4hAKcA6n1uEf87KeW3TBsEoKSmp6G7kA97a16JDtBCGv8mAAIOlzuzP5B5v7WuuPF6tCawVFBTgiSeewPjx4xEREQEASE1NRWxsbKnb+fn5ITo6GqmpqU4fa8aMGXj++efLff23335DSEjdSRsum/HnbadSDQC0MsBTRw9i8eIDPt2GmiqoxAjACHNOOhYvXuz158s8K8+3acdeJGbtdngbiwLsO2UCYEDqvi1YfEzfY5/IBQA/nMvMLfWzpJ67AMCAXdv/Bo4rVfwJiJzz9bGN3JOWDainGU1CFRzYtAq18R2B+xv5Cvc18qW6sr/lFAOAH7ILSrDoj40ATAgszvbJ+Tbp4+l97exJ7Zoz2GjBL7/84tHHp9rL0/taXl6e7tvWisBacXExrrvuOiiKgpkzZ1b58Z566ik8/PDDtv9nZWWhadOmGDZsmC1oV5sVFxdj6dKlGDp0KPz9fVeOadiZiv8d3m77f6+unTCqOxtVA8DhkH+wfflB9EtJxqjByV5/vqN//IM/Th9EVHwTjBrluKfUiQv5KFy/Gv4mAyaNGQE/k76Wi8fS8/Da9j9RBBNGjRpu29/8g0OB3Dz079sLvZKiPfnjEAGovmMbuSensARv7lwBALipfzuM6tu8mrfINdzfyFe4r5Ev1bX9zWxR8MzmpbAoQElEEwCncXH7JIwayfYP1c1b+1rh36ew8NhOAEBsVBhGjernscem2slb+5pa2ahHjQ+sqUG1o0ePYsWKFaUCX/Hx8UhLSyt1+5KSEqSnpyM+Pt7pYwYGBiIwsHzdvb+/f514g1H5+udpGFG67CcmPKhO/T6r4o7+rZDUKAyXtYv1ye+kkfVvkZlf4vT5/jmfDgBo1SgMwUH6+1BEh8ljFxRbAKMJ6sPnF1sAABEhgfy7k1fVtWN1XdXA3x99W8XgYFoOru7etNb+zbi/ka9wXyNfqiv7mz+kx1Z6bhG2ncwEACQ1CqsTP1td4el9LS5KqzCLDuV1B2k8va+58lg1OrCmBtUOHDiA33//HTExpaeJ9enTBxkZGdi8eTO6d+8OAFixYgUsFgt69epVHZtcr6lTQVUcXqAJDfTD6C6+y95T/xYVDS/YfyYHgDQYd0VYkHbYyC4oQXiA9FzTpoLW6MMKEfnQF7f1QpHZgiB/TgsmIiLviA6VwNrR81K21TS67rT2ofIahmnXnJFuTAQl8oZqvQLOycnBwYMHbf8/fPgwtm7diujoaCQkJOCaa67Bli1bsGjRIpjNZlvftOjoaAQEBKB9+/YYMWIE7rjjDsyaNQvFxcW47777cMMNN3AiaDWILjORhQe66hNjDaylVxhYk4mgbeNdC6z5m4wI9jchv9iM7IJihAfIc6lTQUMCeAFNRMJoNCDIyGMCERF5T9lrkOYMrNVpjeymgjbg9SbVENUaWNu0aRMGDRpk+7/a92zy5Ml47rnnsHDhQgBAly5dSt3v999/x8CBAwEAX375Je677z4MHjwYRqMRV199Nd59912fbD+V1qBcxhpHH1cX9W+RnuM8sLYvVQJrrmasAUB4kJ81sFYCRASgxAIUm2VgQSgz1oiIiIjIR+yrZowGoEkDBtbqsujQABgMgKIADUJ4vUk1Q7VeAQ8cOBCK4nx6YEXfU0VHR+Orr77y5GaRm/xNRoQHyVQeAIjiCkK1UTPWsgtLUFhiRqBf6YwRs0XBwbNqKWiYy48fHuSHtOxCZBXICOIii/a9YGasEREREZGP2C/uJ0QGI8BP30Auqp38TEY0sPbVY4UU1RQ86pBHqStGgX5G9tSpRhFB/jAZpfdZRl5xue8fPZ+LohILgvyNaOrGql54kLyJqUFUaxUo/E0GnswQERERkc/E2AXWmscwW60+UPusMWONagpeAZNHqQe3SA4uqFZGo8H2tzjvoBxU7a/WJi4cRmsAzhXh1gEGamCt0JqxxsEFRERERORL0Qys1TutY6WVTVLD0GreEiLBq2DyKPWNjWWg1S8mNADncgodDjBQJ4Kqb0quighWM9aspaDWjDUOLiAiIiIiX7IPrDWLZqClPpg+NgW39GuB7s0bVPemEAFgYI08TM2S4uCC6tcgVIJf53MLy31vn20iqOv91QAgomzGGgNrRERERFQNmLFW/0SG+KNHi+jq3gwiG5aCkkdFW4M5bCRZ/WJCZRS1w4y1KkwEBex7rEnGWqFFyklZCkpEREREvlQ6Y42BNSLyPQbWyKMSo4IBAPERQdW8JaSeZJQNrBWVWHD4XC6AKgTWAiWAlpVfengBM9aIiIiIyJdKBdaYsUZE1YDpJeRR1/ZoCqPBgBEXxVf3ptR7zgJrh8/losSiIDzQDwmR7gVAbcMLCtWMNfk6A2tERERE5EsJkUEY0yURkcH+iAhi1QwR+R4Da+RRYYF+mNy3RXVvBgGICXMcWFP7q7WOC4PB4PpEUMC+FLRMxlogDylERERE5DsGgwFv39C1ujeDiOoxloIS1VFqxtr5MoG1A7bBBe6VgQJaxlqWOrxAzVjzZ8YaERERERER1R8MrBHVUdEhTjLWqji4ACg/vKDILJlvocxYIyIiIiIionqEgTWiOiraSSno/jOeCKxZe6ypGWscXkBERERERET1EANrRHWUWgp6Ia8IZosCACgoNuNoeh6AqgXWIspmrHF4AREREREREdVDDKwR1VENrKWgigJk5ksA7GBaDhRFgm4NwwIqunuF1Iy1gmILis0Wu4w1loISERERERFR/cHAGlEd5W8yIjJYMsvScwsBaGWgrWPdnwgKAGFBWgAtu6CEGWtERERERERULzGwRlSHxaiTQXOkz9o+D0wEBSRoF2ydAJpdWKJlrHF4AREREREREdUjDKwR1WENQksPMNjvgYmgKrUcNKegBEUWyX4L8WfGGhEREREREdUfDKwR1WHqAIPzamDtTA4AzwbWsgvsM9YYWCMiIiIiIqL6g4E1ojpMLQW9kFuE7IJinMzIBwC0iQur8mOH2yaD2vdYYykoERERERER1R8MrBHVYfYZawfSJFstLiIQUSHuTwRV2TLWCottGWuhHF5ARERERERE9QgDa0R1WLRdj7UDZzzXXw0AIuwz1ji8gIiIiIiIiOohtwJrq1evxsSJE9GnTx+cPHkSAPD555/jzz//9OjGEVHV2AfW9qV6rr8aoGWsZeYXo1jh8AIiIiIiIiKqf1wOrH3//fcYPnw4goOD8ffff6OwsBAAkJmZienTp3t8A4nIffaloPttGWtV768GaIG1tOxC29c4vICIiIiIiIjqE5cDay+++CJmzZqFjz76CP7+/rav9+vXD1u2bPHoxhFR1cSEBgIA0nML7QJrni0FTc2SwJrJaECAidXlREREREREVH+43BBp37596N+/f7mvR0ZGIiMjwxPbREQeEh0mGWtnswthUeRrrT1cCnrGGlgLCTDBYDB45LGJiIiIiIiIagOXA2vx8fE4ePAgWrRoUerrf/75J1q2bOmp7SIiD4ixloKqQbXGUcEI89CAgXBrxtqZrAIA7K9GRERERFQTmc1mFBcX+/Q5i4uL4efnh4KCApjNZp8+N9Uv7u5r/v7+MJk8cw3r8hX2HXfcgQceeABz5syBwWDAqVOnsG7dOjz66KN45plnPLJRROQZQf4mhASYkGcd29k23jPZaoCWsXYhT96kQwIYWCMiIiIiqikURUFqamq1VJYpioL4+HgcP36cVS3kVVXZ16KiohAfH1/lfdTlwNqTTz4Ji8WCwYMHIy8vD/3790dgYCAeffRRTJ06tUobQ0Se1yAkAHlF+QA8118N0DLWVMEMrBERERER1RhqUC02NhYhISE+DXBZLBbk5OQgLCwMRiP7MJP3uLOvKYqCvLw8pKWlAQASEhKqtA0uB9YMBgP+/e9/47HHHsPBgweRk5ODDh06ICzMM5MGicizYsICcDJDDax57nWqZqypmLFGRERERFQzmM1mW1AtJibG589vsVhQVFSEoKAgBtbIq9zd14KDgwEAaWlpiI2NrVJZqNvNlgICAtChQwe3n5iIfCPa2mcN8GzGWkSZjDUG1oiIiIiIaga1p1pISEg1bwlRzaW+PoqLi30bWBs0aFCFKaQrVqxwe2OIyPPUwJrRACTHejNjzTNDEYiIiIiIyDPY34zIOU+9Ply+Eu7SpUup/xcXF2Pr1q3YuXMnJk+e7JGNIiLPUSeDNo8JRZAHJ3eGsRSUiIiIiIiI6jmXA2tvvfWWw68/99xzyMnJqfIGEZFnNQoPBODZ/moA4G8yItjfhPximTjKwBoREREREdUmN998MzIyMrBgwQIAwMCBA9GlSxe8/fbbPt2OlStXYtCgQbhw4QKioqJ8+txV1aJFCzz44IN48MEHAUgW2Pz58zFmzJhq3S5f8lgXwYkTJ2LOnDmeejgi8pDRXRrj6m5NcM/AZI8/tn05KANrRERERERUVTfffDMMBgMMBgMCAgKQnJyMadOmoaSkxOvP/cMPP+CFF17QdduVK1fCYDAgIyPDuxtltW3bNlx11VWIjY1FUFAQWrRogeuvv9422bKqWrRo4ZGA4unTpzFy5Ei376/+7Q0GA/z8/NCsWTM8/PDDKCwstN3mk08+KXWbjh074tZbb/XY78JVHmuKtG7dOgQFBXnq4YjIQ+IigvDGdZ298tjhQX5Iy5YDXLAHy0yJiIiIiKj+GjFiBObOnYvCwkIsXrwY9957L/z9/fHUU0+Vu21RURECAgIcPIrroqOjPfI4nnb27FkMHjwYV1xxBZYsWYKoqCgcOXIECxcuRG5ubnVvXinx8fFVfoy5c+dixIgRKC4uxrZt23DLLbcgNDS0VNAzIiIC+/btQ0lJCdatW4epU6fi9OnTWLJkSZWf31UuZ6yNGzeu1L+xY8eid+/euOWWW3DnnXd6YxuJqIYKt5sMGhrI4QVERERERFR1gYGBiI+PR/PmzXH33XdjyJAhWLhwIQDJaBszZgxeeuklJCYmom3btgCA48eP47rrrkNUVBSio6MxevRoHDlyxPaYZrMZDz/8MKKiohATE4PHH38ciqKUet6BAwfaShoBoLCwEE888QSaNm2KwMBAJCcn4+OPP8aRI0cwaNAgAECDBg1gMBhw8803AwAsFgtmzJiBpKQkBAcHo3Pnzvjuu+9KPc/ixYvRpk0bBAcHY9CgQaW205E1a9YgMzMTs2fPRteuXZGUlIRBgwbhrbfeQlJSEhRFQXJyMl5//fVS99u6dSsMBgMOHjwIRVHw3HPPoVmzZggMDERiYiLuv/9+28999OhRPPTQQ7ZMMNX333+Pjh07IjAwEC1atMAbb7xR4bYaDAZbaS0AnDhxAuPHj0d0dDRCQ0PRo0cPbNiwocLHiIqKQnx8PJo2bYorrrgCo0ePxpYtW8o9T3x8PBITEzF06FBMnToVy5YtQ35+foWP7Q0uXwlHRkaW+r/RaETbtm0xbdo0DBs2zGMbRkQ1n30pKDPWiIiIiIhqLkVRbP2Rvc1isSC/yAy/ohIYjdKbuSoTGIODg3H+/Hnb/5cvX46IiAgsXboUgAxVHD58OPr06YPVq1fDz88PL774IkaMGIHt27cjICAAb7zxBj755BPMmTMH7du3xxtvvIH58+fjsssuc/q8N910E9atW4d3330XnTt3xuHDh3Hu3Dk0bdoU33//Pa6++mrs27cPERERCA4OBgDMmDEDX3zxBWbNmoXWrVtj1apVmDhxIho1aoQBAwbg+PHjGDduHO69915MmTIFmzZtwiOPPFLhzx8fH4+SkhLMnz8f11xzTbnfpcFgwK233oq5c+fi0UcftX197ty56N+/P5KTk/Hdd9/hrbfewjfffIOOHTsiNTUV27ZtAyAlsJ07d8aUKVNwxx132O6/efNmXHfddXjuuedw/fXXY+3atbjnnnsQExNjCyRWJCcnBwMGDEDjxo2xcOFCxMfHY8uWLbBYLJXeV7V//36sWLGi0ucLDg6GxWLxSclwWS4H1ubOneuN7SCiWijCLmONPdaIiIiIiGqu/GIzOjzr+zI5ANg9bThCAlyvcFEUBcuXL8eSJUswdepU29dDQ0Mxe/ZsWwnoF198AYvFgtmzZ9uCTnPnzkVUVBRWrlyJYcOG4e2338ZTTz2FcePGAQBmzZpVYdng/v37MW/ePCxduhRDhgwBALRs2dL2fbVsNDY21jZwoLCwENOnT8eyZcvQp08f233+/PNPfPjhhxgwYABmzpyJVq1a2TK/2rZtix07duCVV15xui29e/fGv/71L9x4442466670LNnT1x22WW46aabEBcXB0Ay+Z599ln89ddf6NmzJ4qLi/HVV1/ZstiOHTuG+Ph4DBkyBP7+/mjWrBl69uxp+1lMJhPCw8NLlXK++eabGDx4MJ555hkAQJs2bbB792689tprugJrX331Fc6ePYuNGzfafl/JyZX3/h4/fjxMJhNKSkpQWFiIK664wmEZsOrQoUP48MMP0aNHD4SHh1f6+J7mseEFRFT/cHgBERERERF52qJFixAWFoagoCCMHDkS119/PZ577jnb91NSUkr1Vdu2bRsOHjyI8PBwhIWFISwsDNHR0SgoKMChQ4eQmZmJ06dPo1evXrb7+Pn5oUePHk63YevWrTCZTBgwYIDu7T548CDy8vIwdOhQ23aEhYXhs88+w6FDhwAAe/bsKbUdAGxBuIq89NJLSE1NxaxZs9CxY0fMmjUL7dq1w44dOwAAiYmJuPzyy21DJX/66ScUFhbi2muvBQBce+21yM/PR8uWLXHHHXdg/vz5lWZ37dmzB/369Sv1tX79+uHAgQMwmyvPfty6dSu6du3qcu+6t956C1u3bsW2bduwaNEi7N+/H5MmTSp1m8zMTNvv9+KLL0ZcXBy+/PJLl57HU3SFjNWaYT3S09OrtEFEVHswsEZEREREVDsE+5uwe9pwnzyXxWJBdlY2wiPCbaWgrhg0aBBmzpyJgIAAJCYmws+vdOgiNDS01P9zcnLQvXt3h4GVRo0auf4DALbSTlfk5OQAAH7++Wc0bty41PcCAwPd2g57MTExuPbaa3Httddi+vTp6Nq1K15//XV8+umnAIDbb78dkyZNwltvvYW5c+fi+uuvR0hICACgadOm2LdvH5YtW4alS5finnvuwWuvvYY//vgD/v7+FT2t29z5HQJS+qpmtrVt2xbZ2dkYP348XnzxRdvXw8PDbX3XQkNDERcXB6OxenLHdAXWPDFylYjqnnCWghIRERER1QoGg8Gtckx3WCwWlASYEBLg51awIzQ0VFfJoKpbt2749ttvERsbi4iICIe3SUhIwIYNG9C/f38AQElJCTZv3oxu3bo5vH1KSgosFgv++OMPWymoPTVjzj5zq0OHDggMDMSxY8ecZrq1b9/eNohBtX79+sp/SAfP36pVq1JTQUeNGoXQ0FDMnDkTv/76K1atWlXqPsHBwbjyyitx5ZVX4t5777VlvHXr1g0BAQHlstDat2+PNWvWlPramjVr0KZNG5hMlV//derUCbNnz0Z6enqVJq6qz2U/mMBoNCI5ORkWiwVZWVluP7Yn6HpVTZ482dvbQUS1EDPWiIiIiIiouk2YMAGvvfYaRo8ejWnTpqFJkyY4evQofvjhBzz++ONo0qQJHnjgAbz88sto3bo12rVrhzfffBMZGRlOH7NFixaYPHkybr31VtvwgqNHjyItLQ3XXXcdmjdvDoPBgEWLFmHUqFEIDg5GeHg4Hn30UTz00EOwWCy45JJLkJmZiTVr1iAiIgKTJ0/GXXfdhTfeeAOPPfYYbr/9dmzevBmffPJJhT/fokWL8M033+CGG25AmzZtoCgKfvrpJyxevLhUH3yTyYSbb74ZTz31FFq3bl2qxPSTTz6B2WxGr169EBISgi+++ALBwcFo3ry57eddtWoVbrjhBgQGBqJhw4Z45JFHcPHFF+OFF17A9ddfj3Xr1uH999/HBx98oOvvMn78eEyfPh1jxozBjBkzkJCQgL///huJiYkVlr9mZGQgNTUVFosFBw4cwLRp09CmTRu0b99e1/P6WpXy5AoKCpCVlVXqHxHVH6Uz1nyz+kVERERERGQvJCQEq1atQrNmzTBu3Di0b98et912GwoKCmwZbI888ggmTZqEyZMno0+fPggPD8fYsWMrfNyZM2fimmuuwT333IN27drhjjvusGWINW7cGM8//zyefPJJxMXF4b777gMAvPDCC3jmmWcwY8YMtG/fHiNGjMDPP/+MpKQkAECzZs3w/fffY8GCBejcuTNmzZqF6dOnV7gdHTp0QEhICB555BF06dIFvXv3xrx58zB79uxyvcduu+02FBUV4ZZbbin19aioKHz00Ufo168fOnXqhGXLluGnn35CTEwMAGDatGk4cuQIWrVqZSuf7datG+bNm4dvvvkGF110EZ599llMmzZN1+ACQLLqfvvtN8TGxmLUqFFISUnByy+/XGm22y233IKEhAQ0adIE48ePR8eOHfHLL7+UKwmuKQyKoiiu3CE3NxdPPPEE5s2bV2rcrUpPA7uaJisrC5GRkcjMzHSaNlqbFBcXY/HixRg1apTXaqWJAGDJrlTc+flmAMD6JwciPiq0knsQuY/HNvIl7m/kK9zXyJe4v9UfBQUFOHz4MJKSkhAUFOTz51fL8yIiIqqt71V9tXr1agwePBjHjx+3TQyty6qyr1X0OnElTuTyHv74449jxYoVmDlzJgIDAzF79mw8//zzSExMxGeffebqwxFRLRZhl7EWylJQIiIiIiKialFYWIgTJ07gueeew7XXXlsvgmo1hcuBtZ9++gkffPABrr76avj5+eHSSy/F008/jenTp1fbaFMiqh5qjzUDFAT6cSWKiIiIiIioOnz99ddo3rw5MjIy8Oqrr1b35tQrLl8Jp6eno2XLlgCAiIgIpKenAwAuueSSchMniKhui4sIgtEARAbIlCEiIiIiIiLyvZtvvhlmsxmbN29G48aNq3tz6hWXA2stW7bE4cOHAQDt2rXDvHnzAEgmW1RUlEc3johqtkbhgZg7uTumtKt9vRWJiIiIiIiIqsrlwNott9yCbdu2AQCefPJJ/Oc//0FQUBAeeughPPbYYx7fQCKq2fq2ikFjziwgIiIiIiKiekj3rNJHH30Ut99+Ox566CHb14YMGYK9e/di8+bNSE5ORqdOnbyykURERERERERERDWN7oy1H3/8ER07dkTfvn0xZ84c5ObmAgCaN2+OcePGMahGRERERERERET1iu7A2oEDB/D777+jTZs2eOCBBxAfH49bb70Va9eu9eb2ERERERERERER1Ugu9Vjr378/PvnkE6SmpuKdd97BgQMHcMkll6B9+/Z4/fXXcebMGW9tJxERERERERERUY3i8vACAAgNDcWtt96K1atXY//+/Rg3bhxmzJiBZs2aeXr7iIiIiIiIiIg87uabb8aYMWNs/x84cCAefPBBn2/HypUrYTAYkJGRUaMeqypqyu/WF9wKrKlyc3OxevVq/PHHH7hw4QJatmzpqe0iIiIiIiIionrm5ptvhsFggMFgQEBAAJKTkzFt2jSUlJR4/bl/+OEHvPDCC7pu6+sAVosWLWy/l+DgYLRo0QLXXXcdVqxYUep2ffv2xenTpxEZGemR5y0bIHOXK79bRwYOHGj7+Q0GA+Li4nDttdfi6NGjttscOXKk1G1iYmIwbNgw/P3331Xe/oq4FVj7888/ceuttyIhIQH3338/2rRpg9WrV2PPnj2e3j4iIiIiIiIiqkdGjBiB06dP48CBA3jkkUfw3HPP4bXXXnN426KiIo89b3R0NMLDwz32eJ42bdo0nD59Gvv27cNnn32GqKgoDBkyBC+99JLtNgEBAYiPj4fBYKjGLS3PE7/bO+64A6dPn8apU6fw448/4vjx47jpppvK3W7ZsmU4ffo0lixZgpycHIwcOdKrAVDdgbXTp0/j5ZdfRrt27dC/f3/s3bsXb775Jk6fPo05c+agX79+XttIIiIiIiIiIqofAgMDER8fj+bNm+Puu+/GkCFDsHDhQgBaBtVLL72ExMREtG3bFgBw/PhxXHfddYiKikJ0dDRGjx6NI0eO2B7TbDbj4YcfRlRUFGJiYvD4449DUZRSz1u2XLGwsBBPPPEEmjZtisDAQCQnJ+Pjjz/GkSNHMGjQIABAgwYNYDAYcPPNNwMALBYLZsyYgaSkJAQHB6Nz58747rvvSj3P4sWL0aZNGwQHB2PQoEGltrMi4eHhiI+PR7NmzdC/f3/897//xTPPPINnn30W+/btA1A+k+78+fMYP348GjdujJCQEKSkpODrr78u9bjfffcdUlJSEBwcjJiYGAwZMgS5ubl47rnn8Omnn+LHH3+0ZYGtXLkSALBjxw5cdtlltvtMmTIFOTk5Trdd7++2IiEhIYiPj0dCQgJ69+6N++67D1u2bCl3u5iYGMTHx6NHjx62eQAbNmzQ8Rt2j5/eGzZt2hQxMTGYNGkSbrvtNrRv395rG0VEREREREREHqQoQHGeb57LYpHnKjIBRiPgHwJUIYMqODgY58+ft/1/+fLliIiIwNKlSwEAxcXFGD58OPr06YPVq1fDz88PL774IkaMGIHt27cjICAAb7zxBj755BPMmTMH7du3xxtvvIH58+fjsssuc/q8N910E9atW4d3330XnTt3xuHDh3Hu3Dk0bdoU33//Pa6++mrs27cPERERCA4OBgDMmDEDX3zxBWbNmoXWrVtj1apVmDhxIho1aoQBAwbg+PHjGDduHO69915MmTIFmzZtwiOPPOL27+aBBx7ACy+8gB9//BGPP/54ue8XFBSge/fueOKJJxAREYGff/4ZkyZNQqtWrdCzZ0+cPn0a48ePx6uvvoqxY8ciOzsbq1evhqIoePTRR7Fnzx5kZWVh7ty5ACTzLDc31/b73rhxI9LS0nD77bfjvvvuwyeffKJru539bvVKT0/HvHnz0KtXrwpvp/5dPJnZWJbuwNq8efNw1VVXwc9P912IiIiIiIiIqCYozgOmJ/rkqYwAouy/8K9TQECoy4+jKAqWL1+OJUuWYOrUqbavh4aGYvbs2QgICAAAfPHFF7BYLJg9e7atBHLu3LmIiorCypUrMWzYMLz99tt46qmnMG7cOADArFmzsGTJEqfPvX//fsybNw9Lly7FkCFDAKBUX/no6GgAQGxsLKKi5KctLCzE9OnTsWzZMvTp08d2nz///BMffvghBgwYgJkzZ6JVq1Z44403AABt27bFjh078Morr7j8+1G3IzY21mnWW+PGjfHoo4/a/j916lQsWbIE8+bNswXWSkpKMG7cODRv3hwAkJKSYrt9cHAwCgsLER8fb/vap59+ioKCAnz22WcIDZW/6/vvv48rr7wSr7zyCuLi4irc5sp+t8588MEHmD17NhRFQV5eHtq0aYNffvnF6e0zMjLwwgsvICwsDD179qz08d2lO0qm7nxERERERERERN6yaNEihIWFobi4GBaLBTfeeCOee+452/dTUlJsQTUA2LZtGw4ePFiuh1dBQQEOHTqEzMxMnD59ulR2k5+fH3r06FGuHFS1detWmEwmDBgwQPd2Hzx4EHl5eRg6dGiprxcVFaFr164AgD179pTLslKDcO5SFMVpTzWz2Yzp06dj3rx5OHnyJIqKilBYWIiQkBAAQOfOnTF48GCkpKRg+PDhGDZsGK655ho0aNDA6fPt2bMHnTt3tgXVAKBfv36wWCzYt29fpYE1d363ADBhwgT8+9//BgCcOXMG06dPx4gRI2wZjKq+ffvCaDQiNzcXLVu2xLffflvpNlUF08+IiIiIiIiI6jr/EMkc8wGLxYKs7GxEhIfDqJaCumDQoEGYOXMmAgICkJiYWK5yzj6gAwA5OTno3r07vvzyy3KP1ahRI9d/AGglhK5Qe4z9/PPPaNy4canvBQYGurUdlTl//jzOnj2LpKQkh99/7bXX8M477+Dtt99GSkoKQkND8eCDD9pKI00mE5YuXYq1a9fit99+w3vvvYd///vf2LBhg9PHrCp3frcAEBkZieTkZACw9WRLSEjA/Pnzcd9999lu9+2336JDhw6IiYmxZRN6k1tTQYmIiIiIiIioFjEYpBzTV//8Q7TPXeyvFhoaiuTkZDRr1kxXO6pu3brhwIEDiI2NRXJycql/kZGRiIyMREJCQqkG9iUlJdi8ebPTx0xJSYHFYsEff/zh8PtqxpzZbLZ9rUOHDggMDMSxY8fKbUfTpk0BAO3bt8dff/1V6rHWr19f6c/ozDvvvAOj0YgxY8Y4/P6aNWswevRoTJw4EZ07d0bLli2xf//+UrcxGAzo168fnn/+efz9998ICAjA/PnzbT+n/c+o/gzbtm1Dbm5uqecxGo22YRIVqex3q5fJZAIgmYn2mjZtilatWvkkqAYwsEZEREREREREtdiECRPQsGFDjB49GqtXr8bhw4excuVK3H///Thx4gQAafL/8ssvY8GCBdi7dy/uuece2+RMR1q0aIHJkyfj1ltvxYIFC2yPOW/ePABA8+bNYTAYsGjRIpw9exY5OTkIDw/Ho48+ioceegiffvopDh06hC1btuC9997Dp59+CgC46667cODAATz22GPYt28fvvrqK90N/7Ozs5Gamorjx49j1apVmDJlCl588UW89NJLtkyuslq3bm3LSNuzZw/uvPNOnDlzxvb9DRs2YPr06di0aROOHTuGH374AWfPnrUNrGzRogW2b9+Offv24dy5cyguLsaECRMQFBSEyZMnY+fOnfj9998xdepUTJo0SVfJZWW/W2fy8vKQmpqK1NRUbNu2DXfffTeCgoJsE1qri0uBtSNHjuCjjz7Cf/7zH+zcudNb20REREREREREpEtISAhWrVqFZs2aYdy4cWjfvj1uu+02FBQU2HpvPfLII5g0aRImT56MPn36IDw8HGPHjq3wcWfOnIlrrrkG99xzD9q1a4c77rjDlqXVuHFjPP/883jyyScRFxdnK0V84YUX8Mwzz2DGjBlo3749RowYgZ9//tlWVtmsWTN8//33WLBgATp37oxZs2Zh+vTpun7OZ599FgkJCUhOTsakSZOQmZmJ5cuX44knnnB6n6effhrdunXD8OHDMXDgQMTHx5fKbouIiMCqVaswatQotGnTBk8//TTeeOMNjBw5EgBwxx13oG3btujRowcaNWqENWvWICQkBEuWLEF6ejouvvhiXHPNNRg8eDDef/99XT9HZb9bZz766CMkJCQgISEBgwYNwrlz57Bo0SK0bt1a9/N6g0Fx1qmvjN9//x1XXHEF8vPzAUijvzlz5mDixIle3UBfyMrKQmRkJDIzM0s1vKutiouLsXjxYowaNQr+/v7VvTlUx3F/I1/hvka+xP2NfIX7GvkS97f6o6CgAIcPH0ZSUhKCgoJ8/vwWiwVZWVmIiIiQHmtEXlKVfa2i14krcSLdz/rMM89g6NChOHnyJM6fP4877rgDjz/+uEsbTUREREREREREVFfoDqzt3LkT06dPR0JCAho0aIDXXnsNaWlpOH/+vDe3j4iIiIiIiIiIqEbSHVjLyspCw4YNbf8PCQlBcHAwMjMzvbJhRERERERERERENVnlc2vtLFmyBJGRkbb/WywWLF++vNQgg6uuuspzW0dERERERERERFRDuRRYmzx5crmv3XnnnbbPDQYDzGZz1beKiIiIiIiIiKpE56xConrJU68P3YE1i8XikSckIiIiIiIiIu9Rp77m5eUhODi4mreGqGbKy8sDgCpPSXYpY42IiIiIiIiIajaTyYSoqCikpaUBkB7pBoPBZ89vsVhQVFSEgoICGI26W7sTucydfU1RFOTl5SEtLQ1RUVEwmUxV2gaXA2vnz59HTEwMAOD48eP46KOPkJ+fjyuvvBL9+/ev0sYQERERERERUdXFx8cDgC245kuKoiA/Px/BwcE+DehR/VOVfS0qKsr2OqkK3YG1HTt24Morr8Tx48fRunVrfPPNNxgxYgRyc3NhNBrx1ltv4bvvvsOYMWOqvFFERERERERE5D6DwYCEhATExsaiuLjYp89dXFyMVatWoX///lUusyOqiLv7mr+/f5Uz1VS6A2uPP/44UlJS8OWXX+Lzzz/HFVdcgcsvvxwfffQRAGDq1Kl4+eWXXQqsrVq1Cq+99ho2b96M06dPY/78+aXurygK/u///g8fffQRMjIy0K9fP8ycOROtW7e23SY9PR1Tp07FTz/9BKPRiKuvvhrvvPMOwsLCdG8HERERERERUV1kMpk8FkBw5TlLSkoQFBTEwBp5VU3Y13QXO2/cuBEvvfQS+vXrh9dffx2nTp3CPffcA6PRCKPRiKlTp2Lv3r0uPXlubi46d+6M//znPw6//+qrr+Ldd9/FrFmzsGHDBoSGhmL48OEoKCiw3WbChAnYtWsXli5dikWLFmHVqlWYMmWKS9tBRERERERERETkKt0Za+np6bba07CwMISGhqJBgwa27zdo0ADZ2dkuPfnIkSMxcuRIh99TFAVvv/02nn76aYwePRoA8NlnnyEuLg4LFizADTfcgD179uDXX3/Fxo0b0aNHDwDAe++9h1GjRuH1119HYmKiS9tDRERERERERESkl0vDC8o2gvNmE8LDhw8jNTUVQ4YMsX0tMjISvXr1wrp163DDDTdg3bp1iIqKsgXVAGDIkCEwGo3YsGEDxo4d6/CxCwsLUVhYaPt/VlYWAKnN9XXtuTeoP0Nd+Fmo5uP+Rr7CfY18ifsb+Qr3NfIl7m/kK9zXyFe8ta+58nguBdZuvvlmBAYGAgAKCgpw1113ITQ0FABKBao8ITU1FQAQFxdX6utxcXG276WmpiI2NrbU9/38/BAdHW27jSMzZszA888/X+7rv/32G0JCQqq66TXG0qVLq3sTqB7h/ka+wn2NfIn7G/kK9zXyJe5v5Cvc18hXPL2v5eXl6b6t7sDa5MmTS/1/4sSJ5W5z00036X7i6vTUU0/h4Ycftv0/KysLTZs2xbBhwxAREVGNW+YZxcXFWLp0KYYOHcpGkeR13N/IV7ivkS9xfyNf4b5GvsT9jXyF+xr5irf2NbWyUQ/dgbW5c+e6tTHuUvu5nTlzBgkJCbavnzlzBl26dLHdJi0trdT9SkpKSvWDcyQwMNCWeWfP39+/Tr3o69rPQzUb9zfyFe5r5Evc38hXuK+RL3F/I1/hvka+4ul9zZXH0j0V1NeSkpIQHx+P5cuX276WlZWFDRs2oE+fPgCAPn36ICMjA5s3b7bdZsWKFbBYLOjVq5fPt5mIiIiIiIiIiOoPl3qseVpOTg4OHjxo+//hw4exdetWREdHo1mzZnjwwQfx4osvonXr1khKSsIzzzyDxMREjBkzBgDQvn17jBgxAnfccQdmzZqF4uJi3Hfffbjhhhs4EZSIiIiIiIiIiLyqWgNrmzZtwqBBg2z/V/ueTZ48GZ988gkef/xx5ObmYsqUKcjIyMAll1yCX3/9FUFBQbb7fPnll7jvvvswePBgGI1GXH311Xj33Xd9/rMQEREREREREVH9Uq2BtYEDB0JRFKffNxgMmDZtGqZNm+b0NtHR0fjqq6+8sXlERERERERERERO1dgea0RERERERERERDUZA2tERERERERERERuYGCNiIiIiIiIiIjIDQysERERERERERERuYGBNSIiIiIiIiIiIjcwsEZEREREREREROQGBtaIiIiIiIiIiIjcwMAaERERERERERGRGxhYIyIiIiIiIiIicgMDa0RERERERERERG5gYI2IiIiIiIiIiMgNDKwRERERERERERG5gYE1IiIiIiIiIiIiNzCwRkRERERERERE5AYG1oiIiIiIiIiIiNzAwBoREREREREREZEbGFgjIiIiIiIiIiJyAwNrREREREREREREbmBgjYiIiIiIiIiIyA0MrBEREREREREREbmBgTUiIiIiIiIiIiI3MLBGRERERERERETkBgbWiIiIiIiIiIiI3MDAGhERERERERERkRsYWCMiIiIiIiIiInIDA2tERERERERERERuYGCNiIiIiIiIiIjIDQysERERERERERERuYGBNSIiIiIiIiIiIjcwsEZEREREREREROQGBtaIiIiIiIiIiIjcwMAaERERERERERGRGxhYIyIiIiIiIiIicgMDa0RERERERERERG5gYI2IiIiIiIiIiMgNDKwRERERERERERG5gYE1IiIiIiIiIiIiNzCwRkRERERERERE5AYG1oiIiIiIiIiIiNzAwBoREREREREREZEbGFgjIiIiIiIiIiJyAwNrREREREREREREbmBgjYiIiIiIiIiIyA0MrBEREREREREREbmBgTUiIiIiIiIiIiI3MLBGRERERERERETkBgbWiIiIiIiIiIiI3MDAGhERERERERERkRsYWCMiIiIiIiIiInIDA2tERERERERERERuYGCNiIiIiIiIiIjIDQysERERERERERERuYGBNSIiIiIiIiIiIjcwsEZEREREREREROQGBtaIiIiIiIiIiIjcwMAaERERERERERGRGxhYIyIiIiIiIiIicgMDa0RERERERERERG5gYI2IiIiIiIiIiMgNDKwRkffkXwC+nQQcWFrdW0JERERERETkcX7VvQFEVIdt/x+wZyGQeRxoPbS6t4aIiIiIiIjIo5ixRkTek7ZbPp7ZBZQUVe+2EBEREREREXkYA2tE5D1n98pHcxFwdk/1bgsRERERERGRhzGwRkTeoShAml0w7dTWatsUIiIiIiIiIm9gYI2IvCPnDFCQof3/9Nbq2hIiIiIiIiIir2BgjYi8I61M6Scz1oiIiIiIiKiOYWCNiLxDDazFpcjHM7sAc3H1bQ8RERERERGRhzGwRkTeoQ4raDMcCIoEzIXls9iIiIiIiIiIajEG1ojIO9KsE0Fj2wMJneVz9lkjIiIiIiKiOoSBtfpo48fAnJFA7vnq3hKqqxQFOGsfWOsin7PPGhEREREREdUhDKzVR2veBo6tBXb9UN1bQnVV1imgMAswmICYZCCxi3ydGWtERERERERUhzCwVt/kXwAyjsnnx/+q3m2hukvtrxaTDPgFahlrqTs5wIC854/XgIVTAXNJdW8JERER1RWrXgfe6w5cOFrdW0K+knUKsJireyuoFmFgrb5J3aF9foKBNfISW3+1dvIxuiUQaB1goJaIEnlSxjHg9xeBLZ8BB5dW99YQERFRXWAxA+veB84fBDbNqe6tIV/YvRB4sz2w4sXq3hKqRWp0YM1sNuOZZ55BUlISgoOD0apVK7zwwgtQFMV2G0VR8OyzzyIhIQHBwcEYMmQIDhw4UI1bXcOd3qZ9fuEIkJNWbZtCdZiasdaovXw0GICETvI5+6yRN+z4Tvt861fVtx1ERERUs1jMwLoPSicY6HV6m1T8AHKuYbF4dtvIOwoygbx09+67/gP5uGkOUFLouW2iOq1GB9ZeeeUVzJw5E++//z727NmDV155Ba+++iree+89221effVVvPvuu5g1axY2bNiA0NBQDB8+HAUFBdW45TXY6e2l/89yUPKGNGtgTc1YAzgZlLxrx/+0z/f/6v7JFBEREdUtf38OLHkK+OFO1+/7z+/a51kngOPrPbdd5B2FOcCsS6V8N+esa/c9dxA4tk4+L8gA9i/x+OZR3VSjA2tr167F6NGjcfnll6NFixa45pprMGzYMPz1lwSDFEXB22+/jaeffhqjR49Gp06d8Nlnn+HUqVNYsGBB9W58TZVqDaxFNpWPLAclT1MU4Ow++VzNWAOAxK7ykRlr5GmpO4G03YApQPr6mYuAXfOre6uIiIioJvj7S/mYtsv1PmmHrIG1wAj5aL+QRzXT2veAjKNAfjqw5VPX7rvVuq8YrGGS7d96dtuozvKr7g2oSN++ffHf//4X+/fvR5s2bbBt2zb8+eefePPNNwEAhw8fRmpqKoYMGWK7T2RkJHr16oV169bhhhtucPi4hYWFKCzU0jqzsrIAAMXFxSgurv2N1dWfodzPUpwHv3P7YQBg7joZppUvwnJsA8x14Gem6lNuf8s8Dv+iHChGf5RENAPUrzfqCH8AypmdKCnMB4w1+vBDNZCzY5tx2zcwAbAkD4PStCdMy56FZevXMHe5qRq2kuoKp++lRB7GfY18qd7tb+cPwN8ukcC89xdYetym775FufA7vkGunQY+DdOSx6Hsmo+SIS/KYh5VqFr2texU+K19Fwbrf5WNH6Ok1736rjssZvht/Ur+3pc8CtPqV6HsX4KSzDNASLQ3t5qqyFv7miuPV6OvbJ988klkZWWhXbt2MJlMMJvNeOmllzBhwgQAQGpqKgAgLi6u1P3i4uJs33NkxowZeP7558t9/bfffkNISIgHf4LqtXRp6QbeDXIPor9iQYFfJNacCcdgAMqJzfhl0UIoDHJQFan7W2zmNvQBkB0Qi9+X2O2DigWjjEHwLynAn/NnIyu4WfVsKNV6pY5tigVDd32JEACbipKQnhqF4TDAeHIjVvwwB7lB8dW2nQQEF52Df0kuskKaV/emuK3seymRt1THvpaQsRGNsndhZ+MJsBj9Xb6/X0kuzMZAnkfWQvXl2Nb+1P/QBoAFJhhhxrl1X2J9WoKu+8ZmbkMfcxHy/KOx9EwshvtFIij/AjbPew1nIrt6d8PrEF/ua52PfYwWxXm4ENISIUVnEZh9Cn9/8xJOR11c6X1jM7ehT04qCk1hWJLVDv2DmyMq/yh2/+9FHGk0pNL7U/Xz9L6Wl5en+7Y1+l1w3rx5+PLLL/HVV1+hY8eO2Lp1Kx588EEkJiZi8uTJbj/uU089hYcfftj2/6ysLDRt2hTDhg1DRESEJza9WhUXF2Pp0qUYOnQo/P21kyTj5jnAfiCgWQ/0H3srlCMvw5R/AaO6NoHSuFs1bjHVZmX3N+O6Q8A/QFhSD4waNarUbU3p3YBja3FpcgSUzqOcPCKRY46ObYaja+C3NR1KYAS6XvcE4BcEJX8hDIeWYVDMGVgG3FrNW12Pnd0Lv0/vA4pyUXLrMiA+pbq3yCXO3kuJPK3a9rXsVPjNvAuG4jw07XsNlJTRrt3//AH4zb4MSuthMI/72DvbSB5Xr45tFjP83n8CAKBc+giw+lXE5u7DqCEDgIDQSu9uXLoW+AcI6jASoy6/AsaAdcBfH6Jn8FGYR/3b21tf6/l8X0vbA7+tqwEA4de+D8OBpcDat9DD8jfMo/6v0rubvpdBWH7dbsTIYVfB+NcpYOnTSFF2o8OoN7266VQ13trX1MpGPWp0YO2xxx7Dk08+aSvpTElJwdGjRzFjxgxMnjwZ8fGSiXDmzBkkJGgrD2fOnEGXLl2cPm5gYCACAwPLfd3f379OvcGU+3nSdgEAjImdYQwIAJr0BA4sgV/qFqBFr2raSqorbPvbeZnKa4y/CMayr6fGEljzO7MDqEOvNfKtUse23T8AAAwdRsM/OFy+1mU8cGgZTDv/B9NlTwPGGt1OtG7KTgW+HQ8UygmJ/5o3gBu+dO0xzh0EFtwNxHUE+k4FYlp5YUMrV9fODbwq4ziwea78vYIbVPfW1Do+39fWvA4Uy2q835FVQLcJrt1/389AST4M+36G0VIIBIZ5YSPJW+rFse3gKiD7NBDcAKYBjwI7voEh4xj8T6wD2o6s/P5HVgEAjK0Hyzlt5+uBvz6Ecf+v3Odd4Na+dupv4LdngEsfBlpdpu8+v08DFAvQ/ir4JfUDopsD696B8eifMF44CMS2d37f3PPA/l8AAKbuN8Gk/r2X/R+MJzfBmHkUaJjs2s9APufp45orj1Wjrzby8vJgLHNBZDKZYLGOOU5KSoiyfrsAAGlWSURBVEJ8fDyWL19u+35WVhY2bNiAPn36+HRba4XT2+SjOp2xaU/5eHxD9WwPaQ6vAhY/DhTnV/eWVN1Z60TQRu3Kfy+hi3zkZFDyhJJCYPcC+bzTddrX210uTYYzjmmTnch3CnOAr64DMo8DUc0AGIC9i1wbXKIowOJHZMDO5rky2evbicCJTd7aavKExY8Bq98A/ni1ureEKnN2H7Dlc+3//6yU150rDq2Qj5YSHmupZlIb0adcC/gFAm1GyP/3/1r5fbNTZTASDEDSQPlaYjcgupUEpPct9sIGk82Sp4Ejq4Gvb9T33n/od+DgUumlNuQ5+VpkEzknBIC/Pqr4/jv+B1iKgfhOWoZ9WCyQPFg+5xADqkSNDqxdeeWVeOmll/Dzzz/jyJEjmD9/Pt58802MHTsWAGAwGPDggw/ixRdfxMKFC7Fjxw7cdNNNSExMxJgxY6p342sac7H1zQFAQif5aAusbayebSLN0meBvz4E/v6iurekaiwWbSKoo1WhxC7yMXUnYC7x2WZRHXXgN6AgEwhPBJpfon3dPxjoYC1p2va1b7bl6Dpg48euX5jWNeYS4PvbZCEnpCFw049AyjXyvZUv63+cg8vkQt8UACQPBaAAe34CZg8G5owE9v0qxxuqOXLS5DUJyN/KG6+F3PNASZHnH7c+WvY8oJjl9eUXDOSkAml79N+/IKv0ZPl/Vnp8E4mqJD8D2LNIPu9yo3xsPVw+7v+t8mOUuk8ndAJCY+Rzg0GCdACng3rTyc3A0T/l85J84MtrJYvdGYsFWPqMfH7x7aUz3HtOkY/bvpFzRme2Wq/Buk4q/fVO18vH7d/wvIMqVKMDa++99x6uueYa3HPPPWjfvj0effRR3HnnnXjhhRdst3n88ccxdepUTJkyBRdffDFycnLw66+/IigoqBq3vAY6uw8wF0kWR1QL+VpiN8BgArJOAJknq3Xz6jVFAc5J+WStPzHNOCqreKYAoEFS+e9HtwICwuVN8tw+328f1S3b58nHlKvLl3t2Hi8fdy0AivQ3HnWLuRj4dgLw88PAkT+9+1w1maIAvz4hmQB+QcD4b4DolsCAJ2Rs/f5fgJNbKn8ccwnw29Pyea87gYnfAfdsALpMBIz+wLG1wNfXAx/0BjbNBY6tl2No7nnAYvbuz0jObZ8ngRpAshXVLHlPOb4ReLMd8MMdnn3c+ujYeinjNBiB4S8BzfvK1//5Xf9jHFktmWqqw394dhuJyjq8Cljzjrzn6rHrB8BcCMR20ComWlwC+IcA2aeA1B0V3/+Q9fXQclDpr6uBtYPLgdxzujefXLD2PfnYYQyQ2BXITwe+GCtZhI5s/1b+noGRQP/HS3+vxaVSRVOcC2x1sth6epvc3xSgLQaq7Ksgjq+v0o9FdVuNDqyFh4fj7bffxtGjR5Gfn49Dhw7hxRdfRECANt7YYDBg2rRpSE1NRUFBAZYtW4Y2bdpU41bXUKnb5WN8inYBGhgmvWuA0quO5FvZp4GiHPn88Cr9Jwx6FWRKRlxFKz2ecnavfGzYBjA5aOFoNGoZk66UhXlLThozjGqrgkxg/xL5POW68t9v1kfKEIuyvV+u8c8fQN55+fzwKu8+V0229j1g42wABuDq2UBT6wSuhq21v5GerLW/P5NjSXA0cOmj8rXYdsCY/wAPbgf63i8B+nP7gEUPAnOGA+/3AF5rCUyLAV5pIaWjs4cCC6cCxQVe+GGpFEUBtn4ln/tbG4LvXeTZ51j+vCwQ7lkIZJ/x7GPXJ4oifYsAycxo1BZoZQ0cqKWdehy0tmFRs4NTd0hwm8gbLGbgu1vlfPbPt/XdRz0mdblRMs0AwD8IaDlQPj+wxPl9FUULNJft79UwWYI9ihnYNV/vT0B6pR8Gdv8onw94HLjxf7JIl3EM+PIayZa1V5wPrLAm3Vz6sJZdqDIYgJ7WBZmNHznOOvvbWjLc7nIgJLr09/yDgQ5Xyee+qoKgWqlGB9bIg8r2V1M1tQ4tYDlo9VGz1QBp9H1ys2cff91/ZIXv1yc9+7iOpFXQX01VU/qsrX0feL01sOHD6t0Ocs/uhbIS3aid42mTRiPQSQbfeP1EyP7Eur5mrO2ar5VhDJ8OtL+y9PcHPC4Z0geWACcqOMYVZAG/T5fPBz4JBEeV/n5EIjDsBeDhXcCQ52UIT4MkWaUGAChA/gXg/EFZMNryGfD35yAvS90uA5JMgcAQ6+S1PR4MrB1eJRlSgDSm5sWs+/YukteGfwgw8Cn5mho4OLJGelfqoQbhOo8HGllbPxypxwsL5F0nNgG5Z+XzP14Bzuyq+PZn9wMnNsr7TtnFtzZqOWgFgbW03UDOGSmTbta7/PdZDuo962fKcb7VYEkACWsETPweCG0kAfxvJ5ZuCbD+AyDrJBDZFOh1l+PH7HSDZJ2dP1g+M7ekENhhrYDoMtH5/QFg1491ox82eQUDa/XFaTVjrVPpr/t6gMHa94HX28qkFxLnD5T+vysrxnqoqexHVnu/JE7NWIutILCm9lmrzoy184eA5dPk853fV992kPvUk6CUa7WV6LI6W0+EDq1wXj5QVSVFwN6ftP+f3OT911lNc2w98MOd8nnPO4Hed5e/TUwrrU/JyhnOH2vNO3LxFN0K6HGr89sFRQKXPAjcvhR4YCvw1DHgmXPAoweAe9YDNy8Get8rt13/AfuieJuaGdJulAwSMfrJIJvzh6r+2IoCrHhJPg+3ToDf+V3VH7c+MhcDy56Tz/vcC0RYf5+xHYCwOGnToOd8MP0f4MJh+Tu3uARoOUC+/g/LQclLbJnnBmkwv+Duiis81KEFrYcB4XGlv9d6mHw8scl5Kad67ty8rww9KKvjONmW4xuAC0d0/hD1UHYq/Ety9N8+L11bDOt3v/b16JbAhP9JRvThP+Tvb7EAOWeB1W/JbQY/KxmJjgSGaX32yg4x2LdYFuTCE7Xs3bKa95PAXWEmsO+Xyn+OYxuAHXyfqm8YWKsPLBatj0BCmcBaE2upzult3i+XKcyWVaacVC2oQVqJZmgj+ejJwFpBppYBV1Lg/TI1NWMttoPz26gZa6k7qmeAgaIAix6SbCdAfj+F2b7fDnJf1mngsDV7RV01diSmlWTlKpbKV5WL86XhekWNbR05tELuExYnJ2XmIlklry/S9gBfj5fXU9vLgREznAc6Bzwm2QMHlwLHHbQfyDwBrHtfPh86DTC5OC7d5C8TvGLbAy36AYP+JZls6f/omwBH7ikp0l5fXSYAwQ0k2ALIa6qqDq2QvjZq3z6DUV5j6Yer/tj1zZbPJGMjJEZKqlUGg1Yed0hHnzX1PKVpbyAwHEiyBtbYZ428RQ1mDH9JFlZOb5OFGEcsZm2CoxpMsReRaE00UIADSx0/hq0M1EmgJSIBSOovn3OBVqMoMqBs5SvArEvh/+5FuGzPk0DWKX333/Sx9GqOT9GOK6rErsD1n0tAf+d3kiX/xyvS8iOhC3DRNQ4f0ubi2+Xj/l9LB0PVwXFdxgNGk+P7Go3a9PnKpoPu/AGYO1IGOR3ltOT6hIG1+uDCYTno+AUBDduW/l6DFkBorKz+eLs0b9s3UuoIyEkZs9aEmrHW/Rb5eHKzrJx4wpE1WjNpQJvY5g0WM3Buv3xeUSloTDIQECYr42Wz9Xxh+7dy8u8XJMFMxcw3vlrGuPsHAIpc1DVoXvGN1ay1bd84v83Z/cDsIVJe8N1trm2MWpLWYQyQdKl8Xh/KQTOOAwvvB2b2k6bCid2kr5qzk1JAVpzVoRKOstaWvyALAM37SZ+TqgoMA3rcLJ+v+0/VH48cO/Cb9BgMi9OafLe7Qj5Wtc+aomilwT1uk4znFtbXGS9mXVOYo/U4HPAEEBRR+vvq307P4t5B622SrSWkLfpJwDP9Hzk2EHnS+UPSU9PoB3SdCIx8Vb7+xyuOJ9ke+l36FwdHA21GOH5MtRzUUZ+1kkI5fwbKDy6wpy7sbf9f/e7Xay6Rxc5fnwLe6QTM6gesnG7r7x1UkgXTgimVL6YXFwAb/iuf933A8SJd8mBgtPX9fN371r6uAIa9WH6IVVkNW1vL3hWZ4g7I8D71mNdlQsX3V8tBDyyVTDlHts+TgJp67aVWV1C9wMBafaD2V4vtUL6hvMFgVw7qxQEGFovWyyqkoXxc/ab3nq82UXustRwggU/F4rnMMnX1WJ3QeUDHeHF3ZRyVi2K/IAnYOmM0aiXJvi4HzT0PLPmXfD7gCe2Ei6vsNYOiAGl7K+3xY1TLwDpVkK2m6jhWpjyd2el4AtjWr4H/DpTvA5JNlbZX3/YWFwB7f5bPLxqnZenU5cBadiqw+HHgvW7Alk/l5LH1MODGeUBASOX37/+oXBwdWiGlEqpTf8soe0BOkJ1lvbmq553yfEf/5GKOt6g9DDtdr51jqIHRExslw9RdB36T8mr/ECn9BbSLWQbWXLPuP0BumpwPqAt59tTMnNPbpBzLGXOxdo6i9mYLipTgOsD30+pWmAN8fSOwflZ1b4nnqNlqLS6Rfa3T9XL+Zi4CFtxTPmCjloGmXAv4BcAh9fzv4PLyJaXH1svib2isNuTNkfZXyvnF2T2V93yrq7Z8DryeDHx6hbRdyDgm1wFtRgJXvY+Sm39FsTEIxuPrgT8qGV60/Vs5RkU0ATqOcX67zjdIj1UAgCLPpS5sVqbnFOt2fyZtO7Z9LdddzfpKlUNFGrWR45xidvz+s/Ur4Icp8nhNrNfWu+aX7gdHdRoDa/WBOhG0bBmoyhd91v5ZIdlJgRHAjdYU2j0/AWf3ee85a4PiAnkTAoCY1tpJqqfKQf9ZKR8HPiVvdJnHtT5oHmawnwhaUdYKoPVZ8/UAg6XPSGZFbEeg71QtzVxtik3V66//Ah/0At6/WE5aHASBwwpOwnBmhwRLOoyt/DGDGwBtR8rn9llrhTnA/LuBBXfJCPak/lop1AadFySHlks2cHiinESpgbW62Gct97xMEnynC/DXh3JB0+JS4NbfpO9JWCN9jxOdpJXmrLRmIikKsORp+bzT9UDjbp7b7sjGElwFgHUfeO5xSeSe08ps7UuuIhKBxj3k830/u/fYigL8bu2t1vMOKfMFtIvZtN3192LWVTlngbXvyueDn3EcbAiPt7ZxULRzB0dObJTjXkgMEG83EIt91mqG3QvkNbf02YoDpLWJGlhrO0o+GgzAFW9LkO3UFmDde9pt8y9oC16OykBVid1kob8wSwJp9uzLQCta5AmO0jLf6uMQg5w04OdH5Hce3ADofCNw/RfA4/8AN34DdJsEpXEPbGtm7Ze66nXnpeYWi9YKovfdlbeC6PcA0P9xSUgY/pL+bW49TCbGF2RIOakahO3qZGhBWWrWfdmhWJs/kSAvFFm4uGWxBGbzL5QfllBXKQqw/zfgszGut1WpIxhYqw+cDS5QqVH1Exu9l82krpx1nQg06WEtE1H0j8yu6Sxm4I9XXZ+umv4PAEUCjmGxWmDt4Iqq/y2yTluDaAag9VCtfKaiKUhVYAusxbav/MZqnzVfZqwdXmV9AzUAV74jb9rqCtfp7XXnBNTbsk4D+371XLmyqqQI+NPagDbjKPDdrcDswcDRtaVu1iTdWrabPKT8SHVn1BOh7fNkZTt1J/DRIGDbV1K+NOhpYNICoP9jcrtt3+jbH3b+IB87jpVMzAZJQETjutVnrShXGse/00kuzEvy5T3jpoXAzYuAZr1cf8xLrVlr/6yUMux9iyWjzC8IuOwZj/8I6GMdYrDrByn78ISiXFmpL3ShKbMn1ZS+kDv+B1hKpPdN2WN/e2s5qLvTQff+LNlTAWFSFqQKjgKSh1qfn82hdfnjFaAoR4IJFS1IqGVvFV0IHlyu3da+9Mq+z1p9LourbmrPMHOhNlSkNstLB45ZzwPsyzojEoDh1pYCv0/XMs13fi8/e2xHIKEznDIatSEGZXtwqsGfispAVbbpoN/VvyE5G2bJ77pxD+DRg8DYmbLwERBa6mYnG/SGuetNABTJ6Mo+U/6xDiyRdjKBkUD3yZU/t8EAXPZv4L6/Ks80s2c0ab3Wlv6fXIf5hwIdRuu7/0VXy/nL6a3aPvfXR8BPDwBQJEv+irfkGuOiq+X7dT3oqijAgWXSUuWra+X9Q61Sq2cYWKvrFEUrBVWDGWUldgGM/jJWOuNoxY+Xlw58eS2w+g3923DuoJRXwaAdzC55WD5u/xa4UMlz1gb7FsvK+qKHXLuf2mMsJlneJFr0k79F5rGqT1NTSzUSuwAh0doJhJf6rBnOWd9gKuqvplIz1lK3S1DSkZIiWQmbPUSamldFcQHw04Py+cW3AU2tQzvC4619BxXg6JqqPUd9kHMW+Hgo8PX1wKstgY+HAX+8JiV2VT2h3L1AeqKExUmGpX+o9BucOxL4ZoKUTCsKmlywBtYqGlpQVvIQya7ITQMWPQB8dJmcwIUnAJMXSVN9o0l6e8WnSPBoy6cVP2ZRnraKftE4+Wgw1K1y0HMH5fW36lW5KE/oDEz4DrjtNy07xR0NmmurwytelMwKAOh9DxDVtOrbXVZiV6D5JRIA+uu/nnnM354GFt4HrHjBM4+nV2EOsHAqMKOJ9AP0RonJhaP6FxrUC3dHvWnaXSkfj6x2PRBvsWh9+HrdVT6InmK9YHGS2Up2zh8CNs+Vz4dOq7gPkVoOemil89+rmlGfPLj015v2kuB4zhlWI1QXc0npoOjmT2r/6+PAb1JaF3dR+Z6qXW6UILu5CPjRWhKqHpO6Tqi8pUAbB+fFeenadZOaxV6R1sNlcTzrhAxZsZd5Etj2rRyzP+gLfDsJOLG58sesDQqztf5mlzxYvtVQGZahL0lGbG4a8MMd5c/911qzDnvcLANRvKnrJDlW5Vvf5y4aKz1Z9QiN0a6ntn8jJfaLH5X/97kPGPmKtt+p56l7f5bFuJpAUYBNc7SBDVV9rIPL5Lrgy6ulWsMvWCqCHLUbqAcYWKvrsk8DeedkEluck0mN/sFamWhlGVdLn5U3oOXT9PcBUy9k2gzXVhWadJc3LMWsHUxrM7UcJW23a9NV1f5qDVvLx4BQoFlv+byq5aBqKYd6YqCeQBxbD+RnVO2xHTCoJ9J6MtZikiVwUpyn/Q7sFeUC34yXN+0TG6WnU1Wsfh1IPwSExcs4bnvqVCdvT0yt7UqKpLl/5nF541QsUj7++4vSo+yNtsD8u2TVtiDLtcdWFK25/MV3AAOfBO7/W96YDUZpgP6fXjB9fzNCi85CCQjVSkL0MPlrJzh/fyErrK2HA3etkWC2ymCQ4A4gK5Bl+67YO7hUSkgjmwGNu2tfryuBtd0/yt81bbcEO6/7HJjyh2S/eqL/2aWPyiLC0T9lSmFoI+ASFxcmXKFmrW2eW/Uss/wMrax41wLfZSkc3wjMukR6wwBSxvL19Z7Lmss9JxeA73SWcmx1YrUzqTtlccRotzJvr2Ey0Ki9BDT3u7igs+dH6XsYGKH97ey1GSnvIRlHgRObXHvs+mbN2/I3aD2s8j5EzftKma2zxb3c81qvwrLZPP5BElwDakefNUVx/1xIUeQ9oqZlTJ7YKCVYQVGS6Xn+QO1/L9q3WD6qLR3sGawVCIERshC36EH5aPQDUq6r/LFbXSa3PbffWkEC67mzIseuiITKH8M/CGh/lXy+8WN5b/jxXmmb8FYHYP4UOWan7QL2LARmXwZ8epWUTNfmoOfmT2Vfi0mWieCV8Q8Grv1E+mUe/gP4067P9onNsrht9JeFFG8LiQZS7CaIdtFZBqrqdL18XD9L69t8ycPl+8M27iaVDMV2C7HVbcunkgTy472Vv8c7oyhyjTpnOPDF1XLc8QuWwOKD2+X3oLc9SB3DwFpdp5aBNmwjBzVn1JOhivqsHV0H/P259v+FUyuPwBdkafXrve4s/b1LH5GPWz5znBZcm6hBJcUsTUz1Om89qMW01r7miT5ril2PFLU8o0EL63AEs+d6uFkZFLOWfacnsGY0acHcsn3W8tKlPv/gMjlQG/2kX4i7b0ppe7WS41GvSk8OewysVU5RZEXu+HpJ079rNfDgDkl3b3u5nMDnpknPie9vA2b2da209tg62Q/8goAe1l4c4XHAlW8Dd6+T8g/FDKO1V5PS9nJ9jfLtdZkgQTqjn7zpj//GcSnpRVdLkCfrpPSBdMZWBjqm9IlUc2ugrrb2WTMXA0v+Dcy7SfooNe8H3LkK6HCV5wYKAJKZ1m2S9v+BT5WfUuhJbUbIVNKCTO09yV1bv5ITZQDISQVOeHHwDyB/k99nyEnshcPS2HnYSxJYOrQC+Gx01UrZzSUyie29btagnSILcp+PBbJOOb+f2mOm7Ui5UHFELQfdW8FrqSyLWZte2edex48dEKINSKjrZTZVUZSrHav0BK4DQrXzQUfloIdXAlCkzM5R0KE29VlbOQN4NaniidHO7Pxe3hO/v61cu4JqddBaBpo8WAscqNmKtVFJoVZ67CiwBkgfzeHWfp3qNUrrYfou7IMigWZ95HM1+G/rr3aZ/u1Uf9c7vwPm3ykLeBcOyzlHYjeg7/3AdZ/JeYjRTwJLn10lGeF7F9e+EtKSIhlUAMjPVtk0TlWjtsDl1oqn36drrx21/2PKtdKf0xd63S2BvPgULaFBrzYjZN8pyZf/D3hSFu3LniMZDHalwjXgferEZmDxY9r/t7lRKp51SipJPh8rMQO/IKD3vcAD26TXndoLtZ5iYK2uq2xwgaqJtTTO2QVCSZFW5phyrZzYXzgivXcqsvUrKSFq2Lb86maLS+V5zYXaAbq2si97UIOZetgy1pK1r6lv5kdWu1/mc/4gkH0KMAWWfsNobe1L4+Fy0NDCNBjMRbISFdlM350c9VnLOg18crnsh0GRwE0/ygoIIFlrrqZSWyzS98BSLG+E6qqivRaXADBIP7raHuD1lo2zraWRBuCajyXDMqqZBMHGfwU8fhiY/JOcYIXFS1bbH6/of3w1W63T9eWDXbHtZODJ5J9gie8Ms8Eflh63u/4zJHQCblsK3LNB0tSdnQj6BQI9bpPP1890fJuiXK1XodoYXxXdUoYZ1MY+a9mpspKuNhDue7/0UguP987zXfqIlOg27g5009FTpSqMRi0bcf0HzkvQK2OxABs/ks+DouTj7oVV3jynzh+SgNofL8uiSMp1wN1rgL73AZMXSsPok5uAOSPc6x93ZA3wYX/gl8ck6BifIkHnmGTJWvp8rOOgnblYWjkAjstAVe2sgbWDy4HifH3btPMHOR4HRUkTa2fUi9ld88tPBSSx+0c5B4tuqQUQKmMrB3UQWDu4ovRtykoaKB+P/Fmz/yb5GfK+o1iAnx/VhkjpkXsO+MUui/7H+/Tv23qtfQ+Ye7k8lyvU/mrJQ7VSrN0LXX+cmuLIatl/wxOAhK7Ob9d1ItDKrjS5oqEFZal92/b/as3EsRtcoFdSfylVtQ+k3fg/4ImjwJTfgWEvSA+vMR9INn7PKRKQOLlJqjNm9ZMesFV5X8rPkECkL7Lgdn4ni49hcTKh0xVdbgQ63SCvve9uk2DPHut7aN/7PL+tzsRfBNy7Qc5xXF009A/SzlkuewYY9JTzx1Dfpw4uq95ezrnnZMHUXCSJFoAsKri6zy39P1kMNwVKcPKBbcCI6bIYTgys1Xm2/moVNPAEtBXK1J2Ogxfr/yOZWCENgZGvSiYJIBcozspHLRaZHgcAvaY4juSrWWsbP/Z8M3RfMZdomWeAFsysjKLY9Vizy1iL7yQXm0U57l+Yq9lqzXqXzlRUpxcdWOrRFbLwAmsPtEZt9a9clZ0Mev4QMGeYtfQsHrjlF2mMPuBxCdZlHgNWvebahm35VLKs/EOBUa87fuMLiZY3WIDTQR355w/glyfk86HPa8FZe34BcmI57AVgrHVQyV8faY1dK5J+WJvgpQY+HEnqD/Nty/Fz5/9CSXRzamSTHqWD2M70uFVWMk/85bgfyv5fZaWyQQvp32WvtvZZO/InMOtSaRIdEC6ln8NeqLRvSpVENgEe3Anc8qt3n0fV5UYJ1lw4opUXuerQCikZCoyUXiqAZDZ6+mJGUYBNc6X08+RmWWi4+mPg6o+keT8g+/Mtv0og99w+CcDpLe3IOiUXNZ+MkhKl4AbA5W9KuW/bkcCk+XIxe3Yv8NV15c8LDi4Dcs9KdmfZXlv2EjrL8bs4T1+mtLlEgoiABMDLZhjbazlItjs3zTPH7hObJNBYl6h9dLpO1H/xqC6CHllduhxeLf8BnP/NE7vIa6MwUzv/rIm2fCbnWIBk5v54r/5zol8et04X7yCvvfRDkn3jKQeXSw/Ho3+6lm2WfUY7/0weLH+LxK6ysFjVLN3qolYqtBlR8bmlwQBc9a5cozRIklYPeqnnxUfXyD6beVzKoZv31f8YRpNkdj91UguktRnmOAs7qhkw6jXJ+r/kIXm/Tdstfcdc7dMMyAL8nOHAK82BF2OBaTHA9CbA622krP+DvpIZt/hxz/S0tliANdYMs953y2Kkqy5/QxZvsk/JYrpikV64cR2rvn2uiGnlPNu6MkOeBx77B+j/aMW3a9RWrussJdJL2BMyjkkZak6avtubS4DvbpE+gDHJwO3L5Vwo62TFE6DLyjmr/Qw3LwJGvuy9hddaioG1uq6yiaCqyMYyzU4xAye3lP7ehSPASusFxPCXrI3wh8qKAxQ5ISkpLP+YB5dpFyCdnKxotB4uJQVF2cBfs135yWqOjKOSdadK3aHvfrnnrOOIDaUn2hiN2omtuyWbtv5qZRqMN+0tb+J557Q+KR4QXmDNlGikowxUpWasnd4uWWtzRsibRYMk4LYl2htsQKh2Abv2PSBNZ6lt+mFg2f/J55f9u+Km6LZpZiwHLSX9MPC/yXJc6HS9rMJWptUgKQ9VzNJ7orKAw4YPASiy2hxb+eALxWDSt+1VER6nrTJucJC1ZisDHef4YrU2BdZKCmUa66dXSYAitgMwZaWUfvpCQIgEZn3yXKFaqbGaJekqtWdo1wmSAesfIkF/Dx5PUZQHfHOj9AsqzpOg9d1rS/eEUcW2k+NlTLJcEM4Z7njasqLI8XXn93KB9V4PyTowGCVDc+oWGexitL6+oppJcC0oShZ4vp1UOoNabRDe6XrpYeiMwaCVbOqZDrpjnixUBUeXbx9Rll8A0GGMfL6zCr2uCnNkuM3swRJorCvvA+cPSbDAYNQmI+uR0FkCloVZEtRVnd0rF8J+Qc6z34wm7fh3eKXbm+5V5hJtYt0lD1t7Pq0CNn1c+X33LpbXkMEIjP6PtEMAJMv3pINFGFflnJVepapt3+gP2h9cJh8TumjlWGrW2uZPal+5oaJogTU9PVUjmwBTNwN3/enae0pMsmR0mou0QTpNe5WbbFkpo8m1FhVhscCQ54CHdgKD/g3AIIvBrk5RXjm9dLWRYpZrqpwzcv2WtkuO4X99KOX+8+923NtYrwO/SaJFQLj2fuqqwDDpt2YK1Mop+051f5uqg9GofzK9/eTYqtqzSBbcfn0CmNlPX9n9ihfkGOcfClz/BRDaUNsmVyYH//2ZvE4SuwFNe7q3/XUcA2t1Wf4FOeEHpLyjMo7KQRVF6rFL8qV0U23YCAAjZshq9bl9jjOJ1AvSbpOcT1sxGoFLrRNC139Qc6amuOKsNSsn0LqynrpTX2qtmq0W2bR8/zt1NdidwJrFDBy2rt6XnWjkF6Cltx9Y4vpjOxGebw2s6QiM2DRsbR1gkCsXg7lpQFyKTBxU05RV7UbJiZWlRCaFVnaiee4gMHeUBC4Tusj464qwz1p5hdlycZ9/Qd5Er3xHf8bDsBdkxffQ8orLjgsytZ4ofSrIVqsOagPdXfNL95kqzNbKbcqWgarUC8ua3GctPwNY/Sbwdidg2XNa8PT2Zfqy+mqrnlMkG/HYOtens6X/o+3PF98uF1HJQ+T/ailLVVks0qNn32J5DQ17CZj0o1w0OhPVDLh1iQRE8s4Bn1wBHFgmgd0/35Kpum+0Bd5OAb67VS6winNloWXKSuCKNx2v2se2lymw/iHyWl5wl2xfXrp2wasnYKP2Wdv/S8XlgVmnpZccIFPm9EyGU4ONu39yvMBXmWPrpQzLPjNo4f0193XrCvWCqdVg1/oWGU3auYN9Oah6PtK8X8U9e2t6n7U9P0rmRmgjYMATknkCSFClomns+RnAz9bz1b5TpTF52xFSnq1YgAVOFpn1UhSZNJybJu1T/EMkyKw3YKf2V7PPKr/oagmApP8DHKll5zent0lGjX+Ido5WmeAo/dMdVQaDluGmDt3QMw3UU4KjpDKjn3Xh8qf79WciHVmj9RC+9hMpPX14ryyU3LkauPU3WSC5Zo78TJYS6av1/sXAvMmuta5RrXlHPva4peKM4srEp8h1JCDnmEkDKr59bXbR1QAMstCRecK9xygpAn59Cvh2gpw7+wXJseKz0ZIx6+y6c/dCGWADAKPf1/pgd7W2cNi7SN8QF4tZsugBoOcd7v0M9QADa3WYQc2catBCKx2piG2AgV1gbc9CuZAwBcjKnP2FdUi0lNcBcoFmf4A+u896Emao/AXYYYxkKeWny5SZ2kbtr9Z6iDTbL86VTJ/KqOWjji5i1Yy1U3+7XpN/aquUYQRFallh9mzloJ7rsxZhKwV1IWPNaNICviUFcrJ+y8/OG1+OfEVOsI6u0ZpmO5K2V7IOsk/JyemN31ZeZtasj0zOvXDYtV4rdZXFAvxwp1aWe8OXFV9IlRXTSuuN9OtTznsFbvlcynEatSvdH6UmSOwCNOsrJ6Ib7TIZ9v0iGaoxyc4XLGpyn7WMY8Cv/wLe6ggsf16a74cnAle+C4z90PVV+tomIkELxqx3MWtt48cAFAmmqVnGHUbLx90LPVMOuvw5ed81BQCTFkjPGT3l9aENgcmLZAGsKBv48mopsVn2nJw455yRptmJXWWh4YavgFt/1dEm4mIpCzb6SabOL4/LqrulWDLh1TL6ijTrI+0N8i/I8duRtL1SrpR5THq4Xqyzj2KzvrL/FmZqAW89SgqlV8zckZLVEdkUuOFrydy/cBj4vZL+sTWdxawF1tQLKFeo5yD2AwzUJvIVlf4C2gXy8Q2uTUn3BUUB1lp7SF58h/RKuvh2CdwU5wEL7nF+gbr0GSD7NBDdSoatqEa8LCWIZ/cAq99wf9s2zpY2A6ZACYS0v1K+rme4grnErkzXLrAWGAZ0sk7H3DS3/P1qMjV43+oy+Tt5k3perHJlcIGnDPq39GnLOy/D4Sp7PynIlEUYKFLq3XGsXOtFJMj7U0InaafS6jIJ7Nz0I3D7Cmv2nyIlfR9eCnx5Xenrvooc/0vaRRj9K27dodfFt0nw78Z5nh2OVNNENtYGW+383vX7XzgqCQhqP/I+9wGP7ge6TgKgSE/jz0ZLn1x7Z/fLMU29z0XjtO8ldJEKhZICYNcPlW/D/iWSFR/cwPmiMjGwVpcZzugsA1WpaZ3H/5IDemG21lup34OSYVRWxzHy5q+YpSRU7cehlsu0HVU++6gsk5+sTgNS6leVFb/qoAbWYjsAcR3k81QdvUXUVOwYB7/XiAR5PCiu1b8D2olwi0u1sh576knXqb8906zfXIywQuvB3JWMNUBbhWwzEpj4fcWrX1HNZFUPkP4jjgKOqTvlYjLnjJQY3/yzvvr/oAhZfQa0bL/6bOUMmcRqCpSgmjtTmi59FAiNlf4zaq9Fe/blOL3vrpknVWpwcNMcrTn1rvny0VkZKFAz+6yd3gZ8fzvwThcJKBXlyGtkzCxpPtt9cs38G3iDekGwawGQcVzffYrytH5VPadoX289TIJg6Yf0l6k7s/lTLRvgqveBFv1cu39QhGSYqUNaIhpL4G/Yi5LR9tQJyVAb9aqUZ+r9e7ceIkFXGGRww7Ln5OsVDS2wZzRpE/32OihzOrJG+mtmnZD3w1t+1h/gNRq1iwW95aCpO4D/DpJVfMUiP8fdayQzWi3tW/+B6xmNNck/v8viUnADfWV0ZamZ7Sc2yQV8cYEWFK0s6NCorSzIlBRUPGm+qtL2SknU/Lv1lzke3wCc2iLvbWoZm9Fa1hkQLj1ZHZWJ/7PSOjEXkvVhv9AUGgNcri4yvyHnIa46s1umMQPA0GkSsFYrRHZ+V/kgqxMb5e8UFCW9F+31sJaD7l2kPxOqJlD7YLqz/7qqeT+Zbg7Ia6ayBQdv8AsExv1X3k/2/2odGFWBxY9JoKNBCwnu6tGkOzD+a2ktcNHVUtJ8YAnw8VDJZi7Mqfj+6vtT5+sdTwV2R7Ne+ia41nbqgp6r00H3LJIA6Kktco10w1fSlikoUo5F4z6S6p8jq+V4qAbYC7OBbydq092HPFf6cQ0GbcjH3zp6MKpDm7pOcm2hvZ5hYK0Os2WsVTYRVBXfSU428tMlHX7FS7I61yBJK9d0ZNQb8maeul1GJudnAFutGUWV9UhRdR4vjZKzT7k3+rw6nbMG1tQGlYC+Pmu2jDUHgTVAO3l1tRy0slT28Dgtk+2gjhX+jR9LQ1VnE+fS/4FRMUMJCJVVf1f0f0xW0PRmRPW+V7Kb8s5Lto29U1uBT6+QUqiEztJY05U3a5aDim3fAKtelc+vfKf8SbpeQREyfhwA/nhVesfY27tIslNCYkqXmNck7S6Xxuv56TKxKz9D62NT2YqdGlhzlqHjKxbr5K0P+8sJnWKWjJIJ30swoct43/U4qykSOsnrXTE7Dvo6svM7oCBDLmLU8k9A9nP1WF2VctB/VmplZgOelAsXd/gHAdd9BjxxBHh4t3zed2r5QTauSrlGGm4DkpVt9HPc882Zdtbsm70/l87E2PkD8PkYCQo07eW4FYCebQMkw6Uw2/ntzCUS+PjvIOk7FNIQuP5LmdSnLuq0Ga6V9i28z/3J3NVNDQKnXOdec/GoZpKZpVhbSxxbK4Gy8ER5D66IwWD3fuqlclB1ES11h5S2bdTZo1edeNz5+tLnB1HNZLIdAKx4sfTgnaJcKQ8GJLvNUVP7DmNkAq6lxLrI7MJE1OJ84PvbJBM6eah23txyoAQo8y9Ufq6mfj95cPkF1fgUoHEP2TZ1v6jpMk/INYXBWD6bzBvs26QkDXC8KO0LcR2186Zf/+W8NHnHdzKV2WCUwIqesvmyz3PNHOC+TRIoUTOSP7pMspwcObtfGzTV9wHXno9kkcvoL8csPYO9SopkH1BLPxt3l/JetWepqtN1wJ1/yEJp7lng83HA8hdkWvG5fXJtfe0njnuhdrpeqnVObtKSRBw5f0irQnO3r149wcBaHWY4Yw3uxOtcefEL0CbcbfxIu+C4/I2KT8jD47TVkpWvyGp2ca6UBerti+AXqDWuXPWavGlU51hivSwW7U2oUTutNExP3wJbxpqTfkb2I+/1lhgV5UnPGEAr5XBEbzno9v/Jxd6mOcAHvaWUoMy2GM7JG4TSsJ3rGS9+AbKCpvckxi9AJtcB0oxXnUh7YpM0X8+/ICeQNy10fdKPfWDNF+PKc87WvGbCWz7XGif3uU+CLlXRZYIEcQuzpHmqPTUroMetNXf1y2iSicYAsGGWrKCbi+S1rmanOqMG1k5s1LLdqsPG2dYm9Sbgomtk6uPkhZKFVF8y1Bzpc5983Phx5T2MFEXLwu5xW/njlZohttvNwFraXuDbm+TCN+VaYOCT7j2OymCQrAtP63mHVgLXYYyUn+rVcqBkhGSdlJV3QI4B390ir6l2V0ipkjsT2hK6SBCopECay5eVly5T7N7vASyfJmWs7a4A7lmv9X+zp5b2pe0G/nzT9e2pbnnp2gVw14nuP456DvLP71oZaKvL9B03vNlnzX4RLdQaHFv6bOUTcSubQN11kmSgmguln6BagbH8BRlSFdm0fNaHymCQc+WgKJl0vu49/T/P0v+TfS20ETBmpvb7NZqATtYG4xW1vwC0Mmj7MlB7atbalk9r3nmHI2oZaNNerh1nquLSR4Hml8ikzurU+16pOCnOlfOxskHazBPaIsylj1atiXxMK8l6unmxBGDO7QM+GqRl5ttb+y4ARYZTNWrj/nPWVyHR2qJcZdnVmSekTYHarqLPfTIBvEFzx7dv2Bq4YznQ/WYACrD6dSn1NfoD137qvMVOWKwc84CKJwer7VBaDwWikyre9nqOgbU6ymQu1AI3rqQ0qwfoDbNkxfaiqyvvpwEAnW+QA4a5UGsC3OtO1y7cut8spWOZx2X17rVWwOyhku1yckvNPBnIOmFdvfeXzD71d526veLgjLlY+rgAzjPWmvWVDMKsE/on+BxfLxcpEY1LTxotSz2QHvpdO3ks6/R26fMAyBtuYZZMqfv0SmmEa2VQhzdUtortKS36AZ2t6cuLHpJSu8/GSI+dZn2kUauenoJlNe0lKfjZpypuYOwJf30EvJ4M/PZv7z6PKzb8VzI0oEjwYOgLld6lUkajFnTf8pkWcD6xSYakGP3191KqLl0nSZp92m7JZACkDLQyNaHPWsYxrWxv1KvANR9L7ziSC9CWA6Wv0hdXSymWE4YTf8kqs1+Q40BF25Gy4p+2y/VjR85Z4Kvr5PjVtLeUgNbkgOfAJ4G71wFXuRA4ACSTTr2o2L1Qei8u+Zf8v+cUyaxzN8BuMGhZa+oFi6JIKef8u4E32kl/rAuHJTNtzEyZjOYsozk0Rl4vALDq9Qr3jRppx3dy3IlP0V+x4Igta/53bYhBss7eU2qftVNbrNPPPaTsItq9f8nruCRf+k1VlCm24UM5r00eojXwtmcwSK/JoChplfHnW9IaZcMs+f6Vb1ecGRQerzVj/32G88wfe/uXaIvYY2aV3yfV4SD7fnW+2Jx9Rs45Aefn6x3HyYCtC0dK983zNEWR7O6ja6v2OLZpoCOrvk16JXaRMvTqfo80GiWLNjBCzpPWvKV9z2KRYFtBpjT8V9ujVFWzXpIN1eJSaRPxv5slW0q9Psg6LRlygNa6h1xnXw7q7Brx6FrgwwGSRWZf+llZZYF/sFSZXP2xVtY8fLr8bSui9uDc9q3j42dRHrDVmul6MYcWVIaBtToqouAYDFCAsDjJKNPLfuUjMBIYPkPf/QwG4Iq3tRdzUJTWMFWvgFApA+n3gKS0KhZ5U/n9JVlBeaONNFT3xEhzT1FPnGKSpVdcbAdJzc49K32+nLlwVLIT/EPk4tuRgBCguXWkvd5yUHV1uOXAii/OErvJinxhlpbhZi8vXdKPS/LlAvTBHXKA9guWOv4P+koDYIsZBmv6sNKorb5t9IRhL8g+dmaHTMArypYTgonfS2mWO/yDgSbW/d+b07P++UPrXbjhw4rTr31lzTvAL4/J533uk5V3PQ3T9WjexzoRSQF+fVJOJtRstZRr9fXAq07BUVofiixrObSexq3V3WdNUSTwXJwrQfruTN8vxWiU4ErjHnKR/vmYUgsGpW66yVpmlnKt44yqkGg5/gDA7h/1b0NxgUzezTgq5Y83fOX9Jt2eENdB3p9cpTZjX/uu1oR5yPPAyFerXnp1kfWC5dAKWST47wBg9mVSJmgulDYNV74LPLxHXs+VBS87jrNOoi6WBQc9k769SVH0Z1Krk5a7Tqrac7a4RDJd0w9J0BiGijPh7UU1lcUFxSI99BwpKZT3wPl3y+umsvLJo+vKL6KFREt/tMBIuRC1D0LYy8/Qfi8VNV2PSNBKnv94RRZ5ochinn0JuDOdx2uLzJXtN9lntMbive6WLOKy4jrKtHRLseMsIkBrT5DQxXlmSkCIVl5uPwHXkywWec/54Q4p01WHZ7iqIEtryeGL/mo1UVQzbT9c+bIEegHJYDqyWq4dxn3kuLzPXWGNZGBOvwe15/rkCgmqbZgpwfpmfaqWIVfftR0pC7UXjpS/llUUqTD49ErJxo1LAe5cVb70szIp1wD3bZS+qmrFRUVaD5eWLDmpjq81d34ngdyo5vqOgfUcA2t1VGTeUflE7+ACVRO7A+bgZ1wLykU1lcmNMEhZpzvT5aKTpHHrPWuBh3ZL9L3dFdJUNvcssP0bOdC7O67Y02zZWta06IAQbRhBReWg59Uy0FYVBzBc7bOmDjqobFS40aiNZD+wpPT3zCWyWpVxTLLwrra+efe5F7hnnZRMluRLttXHw2A4uQmAtRTUV0IbAkPVHmuKTJSc8L+qTzT0dp+1C0fkd6uY5c1VMWsZRdVBUeSkbam1p0f/x6TRuaczZoY8L0HZo2skqKYGH/p4YKqUL/S6S/s87iL9ZRDVGVjb/q1ccJkCgave9VygtC4JDJfjRmxHWQj5bHS5XpKBxRkw7P1J/lPRhOsO1nJQvX3WLBZgwd2yeBQUCdz4P8mUqstaD5UsVcUiH8fNluwHTxxvGrWR8x1LiSwSnN4m+37n8cDty+UCpftk/e8RamlfYIRcAK2fWfVtdEdhtmROvdFOpqZW1iLj9HbJXjIFSCC4KoIiS/fYTOzqWqmumrVWts+axSJZde9fLFNmt30FzLsJeKez9MDLPV/+sQ6vAr4Ypy2iTfhOW0SLbKJlGK58Wf72ZW35zDqBun3lwxdSrpUgsKVEzoNCYyVjRA/7RebjG2Sbf35E2qRsmiONyI9vlHOBH++xXkBf5LzEFJCKEMB5/2G1v5p6TudMd3WIweLy0wOrymIdYKYG7RTr8c1+orZeh5ZLIDEm2XlFR33Q6Xrpy2UpAX6YIvvN8mnyveHTgYZO2shUhclPzq2v/1KOfcfXS3/WjXPk+2rQjdwTEKoFyuyHGJQUAj89IMcKS4ks7LjTb1QVkSh9VfXwC5BenED5clBFkQobQCa48jyyUvwN1VGR+dbAmquTbcLjpIdKr7vca1DYdSLw5FHg0kdcv29ZkY2lPPSGL4HH/wEmL5ITu+I8bXpSdbMNLrALKqmlF6kVBNYqmghqTz0BPLK68mmpeenaCaWe3nbqSdj+Mn3Wlj8nJ8L+oZJBYd+rJzpJ+pdd+a71gmMTDNmnAACKr0pBVV1vkuyq3vdYMz080KfLFlhb7fnS46Jc4JsJ0gg/sStw2xLJBti32PmKvjcpCrDs/2QCKCANcy972jtlaFFNJRMVkICsYpaLI7UnYU3XMBloM0I+d6Vhe3X1Wcs5K9mBADDwifp9cVKZkGjJfIluKRfRn48Bcs/Zvt383EoYLCVSplnR+2m7KwAYJLMg41jlz7tyuoy4N/pJ5lx96FkTFCm9nsITJLu4UxUDP2WpTd+jmssC3cN7gLGzJDjkznEtIlEWGgApA3eS0egV+RnSBuPtFFl8yUmVjKzPx8r3nFEvjNqOcq9fXVn2GWqVBaTK3ddBn7XDqyWT8PvbJFMzLE5aD4TESNuL5dOAN9tLFpuapXNwGfDltXLupy6iBYaVfq5O12vBsPl3STaoyn4CdZ97K98XDAbg8rckqx+QiZ+u/C6jmkpWPSCLnRtny+t90UNSCfDxEAkiHlwm5eVXf1xxpmrKNVIJceKv8qXm5hJt4dVZfzVVXAdpeaGYYdzmZjaZI+ZiyVLb9pWc04z7COhpfS3+/DCw7gPXHq86ykBrIjVIGxYPnNsPfDJKssbajLT20vKi9lfIBOnYjkBumgS0G7XT2siQ+9QFj50/yOs3O1Wy1LZ8CsAgQfZr5riXFe4utSpj3+LSizcnNsm1rF9Q1TOg6wkG1uqoKDVjzZ3+GgOflMwzd0szgiI9f3HuFwAkXWrtP2OSpoyuTsv0BrWMz74MUg0WVBRYUzPWKrvgje0oq6XFedLroyKHVwFQZEVWT3ldq8Hyuzy3T1ZPAVlFXmvtnTPmA8cN2g0GWfm/d4O8wQMo8IuUiyVfMhplFXnEDM+VTzXuLin2eeeAs3s885iABLEW3AOc2Sl/z+u/lP1EPTn67WnPDkxI2ys9cc4dLH2BobJYJFNAHZ0+4mXPBMMr0u8B6f2n6nOvd5/P08bMBEZ/oDW916O6+qz98riUN8anAH3v993z1lbhcdI4P6KxXMB8PlZKH8zFSDpnfZ+pKFsNkBIsdVrgnp8qvu3Wr2RIDyBZ2XqH/NQFo16TgJcadPGkrhOBR/YB92+V440nMgC73SSLACX5MhnS0XHaYpayvgtHq/58eeelWf7bKdIGI/+CZO4Mny7Bp9NbgS+vcTz9tKRQ64PkqYsg+2Cann679lpY9+uzeyTA9OV1MnTg1N+S0TXo38D9fwNXvCkVCmNmyaKTuVCCNP8dKFMKvx4vgynajHC+iKYGIUIbST/M3+0yzPb8KEG70Eb6s/jCGknGyE0LJWvIVT1ulWbjo16XTPBukyXY2bi7TJr2C5Jg2ajXgNhKFiXD47W/g/r3VZ3cJMeqoCh9E7ytWWvGrZ9LVllVlRTJAJKd38siwbVzpQ3MyFe0xbQlT0kmoh7mEuk7B9TfMlB7aqkzIOcRoY2kv6Uv+nDGtAJuXyZDqPxDpPKAGUtV12oQEBwtAcu178hx7vgGuXae8J0Mz/B1n9WETnK+aC6S17JKnbZ80dWeWaipB/yqewPIC8zFCC+wlkq6Wgpa08VfJI2ON8wEFj8G3L3WvVHynqAoWiloQ/vAmvV3XlEpqDq9qrKMNaNRDsLbv5VAYtKlzm+rlltUVgaqCo6SVOGja2SiVLPeMp4ZkAN7xzEV3z8iERj/NUoOrsDazXtxaU1uuK2XX4D0kDi0XAKVcR2d3zbjmJzQ6sm6Wv2GNqHn+s8lGxOQIPb2b6XB8675wEU6muJX5ux+4MNL5Q1SFdpIJppFNpHeHZnHreWYBuCKt7SJYd4UECJZJN/fBjRsI30dapOQaK3Jq15qn7Ud86Qc1BcBlL2LJRPKYJKFCE/2YKnLoppJcG3OCFkU+ep6GDrdiKCSDCihsTCokz8r0v4qOZ7uXug8cHzkTwnQAMAlD1dtamNt5c33Ck/3bDQYpJT6g76SOf7drRJAyE2TzNDcNAmGqUGKDqOBq+dISZUrcs+iw8lv4Pf+3dIXEZBFsv6PSk9Ho0mOH59cIUH6L6+VrD/70tZ9v0ggLjxRm+hZVY27S6miogBNLnbtvqEx8v6YukPKrAH53XW/BRjwROlG/f5BMoW68w2SJfHXh8CuBVofovZXyu+1ogbeoQ0lUP3NjbJA2HaUnNesfV++f/Htri3CxbSqeAhUZZr30frklqUokl2n9/jcebxkuG37RqpK1NeQOg201WX6FsM7jgF+fRKGzOOIzdoBwMFUXL2KC6SE98ASKT2+7jMty8xgkECMf4hkxS+fJlnbg/5d8ev/+HqgIEMCD/ataeqz1kMkSLnhQ8cDLrwpIEQW2a96r+p9MEmY/OWYvuljrbS3UTtZNKjK8aaqukyQSoetX8pCYu45OZcEpAyUdGHouS46tw8mpQRKYIT79dk12aCnJOvn/EGtCXp1yEmTwIrBKCvKKjWwduGwNGF1xJaxpqNHgt4+a7b+ai5kAqjloDu+kzLFknzJZLvsGX33NxigtOiP7OAm+p+zptPTZ23n98D7PYFZl8iFzqHfnWec7ftVmyY56rXSfQ/CYrVV3eXPV17uq8eKFySoFhQlJ7WA9Cc8tUX6P617X4JqBqNkYfkiqKZKuUaCFxN/qD8rn57os3Z4FTCzn2SyVFQGVpAppTcA0Pe+6p9uVts0bC1loYGRwLF1MP0sr01L15sqn8gFaM35j29w3MPo3EE5zlqKgQ5j9B9nqXpFt5QyeUAuNHbMk/fbtF1ybFUsAAzyb/ePwE/3u9ZK4Ow++M0ehNZpi2EozpVziOu/kIXDlGu0C9r4FOCmBbb9E1/fULrE/G/r5LYu4z13EWzyA+76E7h7jXtBevuMt/ZXAfdskNJKZ8EBgwFoejFw9WzgoV3yex/4L+Caufpeg+0uB7pMBKDIlNCDy+W9zxQoJac1hcHg2u+z7SjpNZxxtPTAKb391VT+wbZJox1PfSMtKtxRlCf734Elkn03/pvypZsGgyweDrH2w131muPs/AtHgc2fAPMmy/ERANoMdz04XZcNnQb867TjARe+wKCaZ9lnzra9XDIDqzOoBkifNaO/ZBSf2S19Kc1FMuyucffq3bZahEetOshgLUFU4lNgqAtZRGUFRUrfk/lT5I065VrpaeFrarZagxalV0FDY6SkKOuklP6p5UGq/Aw5GQdKB+ScUTPQTm8FvrpBTjTjLyp9m4xj0v/FYAKa99P/M7QeLv1bjq/XfparZ9fvN1E1sHbkTylLsD+5s5glSPbnm9rXjqyWf427S8lHmxHaiuzZ/cD3twNQ5KTeURCrz72Sbn3hiDQ37n23+9t+crO1eboBuOUXILa9ZDBkHJOBH5nH5WPeeblgq44JP3ozKuuKsn3WXO0FqCjAL0/KRfyZnbKv9HtA+kmVbcS+9P+A7NMSCBj4lGe2v75J6CQ9nD4fA0NxHiwwwdJtMnQdESMby5TRk5ukHNS+fDT3PPDVtZKN0biH9P6qL8HluqD33RIQzT0nCyKhsfJR/TwkRoIM306SFf+gKGlVUNk5WOoO4LMxMOSdQ3ZgAoJHvwG/9qOc3y+xq2SqfT5GAu7fTJBMh/x0ybQGJPPAk6pyHnnpozIkJGmA69MEw+PkPdVVI2ZIBn/GUelpBshETF9m+nhaQIhkQ279Atj2tWTCZZ/R+uq68l5+6SNQdn6PiNyTsCx5Chjn4mCOwhzgq+uBo39KL94bv624muKSB2WR75fHZGGvOF/Kig+tkEXJ9DJ944Ki3OvxXNfx/aLuaNYbGPS0HBt7TqkZf9vQGAlo710kE5T3LJKvX3x79W5XLVMD/pLkaYbUHQAAJa6WNAZ3R6frgGZ9rYMM/uWZx8w+I1N39LL1V3PQH8PWZ21H+e+dt5aBhifIQbUy4fHAgCclw2j/L5Il9f3tpZvYqs2Bm/TQJmXpEdteSgQBOfG54SvW0Sd0loyAwiwg1W66WEGm9HpRg2r9HgAe2C5Nev2CJKj19Q3y99n5vTQA/Wa8NH1t1lf6mDkSEAoMsu7Df7xScUZSRRRFmzDaebz0xzMY5O+Z2EWa0fa+Wy72xs7i2GxfqWqftX9+l6Caf6gcawoyJLvxnS7Ahv9qWY5H/tQmsl31nmeGedRXzXoBN3wJJSgSRxoOcq1/pKPpoCWFwLcTZfEjqhkw/mv+fWobo0laJAx/SY79XcZLcCA+RQJAJj/JllL7Ia3/D7D69Yof88Rm4JPLgbxzsMR3xuo2T0NpPazyQFbTi6UXj3+IBNP+N1myCxSLvNdUd+aDvaAICY65GlSr6nOOsTbML7H2GO1dSyZQV6Tz9fJx1wIpw1QDqQmdJcCrV1gjmMd8CAUGGLd/JT0f9SrMBr64WoJqgRGS4VtRUE3Va4oMvYJBSuC+uVEWidIPyYJw016yGHTrb8Bjh3y7vxD5msEADHgM6H1XzQiqqdTWFBs+BDKPyfA6T7SoqUdq0F+TPEVJHoJDjYZBaeVio9naxGCQcgKDSS5gDi6r2uOd3AJ80FumNamTqCpjmwjatvz3KuqzZpsI6sKo7EFPSQlFx7EAFBnT/P7F0qsn84RWBqqOt9fLYJAG+n5BEmypqKdYfWE0AS2sWX+HV8vHcweB2UO0sodxH0lqfoPmwKhXgQd3yBjygHDJKvruVuDNDhJEjWgivUcqKmPpMlGCJvkXgD/fcm+7//ldMhhMAbK/UM2g9lkD3CsHVfsDdZskpWFjP5Sph7lpkgHwXg+5qF44VW7X/Wbt+ch9rS5DyUP7saPpTa7dT+3FdmSNZKkpivxtjq2VC9Eb57l2EUy1S5fx2iLKihe15s9lHV0rfccKMoGmvWCeMB/FfjoW2lTN+0j5nV8QsP9XbbpzfezZ50hSfy2YljxUFhFru+aXyPlEYaYssqr91SqbBuqA0uJS7E0YK//5+REZeFQZNah2fL1Ujty0QBYh9Oo+GRj3X9lno1sBF98hi7lPHJZBEQOflMdjCShR9UgeIj2ZFbP8v+skLgK6iIG1OkhpNRg7m0yEYj8mvS6K6wj0uks+X/y4+/2pDq8GPr1KSikAaf6th5qx1tBBYE2dxmqf8aTSOxG0rEZtgGs/Ae5cJSOvFbOMZ363m4xIBtwrs+v/KPDUCfcmX9VV9n3WDiyTyWTn9kuJ7y2/SMakvbBYYOjzwEM7pB9McAPpV+cXDNzwZeUlKCY/rQ/J+plAxnHXttdi0bLVLr5dsmKo5nA3sHZmt2QlGIxyrDOapLn3fZuAy98EwuJlVXHhVMmGCk+QgC95hjsl8dFJksWkmIF9PwN/vCoDSgwm4LpP68YFPlWs991A/8fl858flR6m9g6tAD4fJ9nMSf2l56QrmeaqlgPk/cVkXbTxD+X7uL2hLwDXfiqLEXWB0aide/z9pdZ3V29/tTL2x10FS9IAqfz43+SK+60VZgNfXKNNL7zpR/f6LnW6TnqF3b9FFsfbXS6PR0TVz+QPdLJmxsLAkmw3MLBGtdvAJ4GwOEknX/ue6/ff94uswBVly+MAWjPYypytKGPNWgqatlfGkduzZay5GFhTJXSWHkC3/CplH+ZCOTHyD3F9apeKkwNLswXW/pC+SIWSVYA7fgcad3N+v+AGwMAnJIPtqveAyT/pbyDfZrisSJsLgd9fcm17dy+QXisB4cClj7h2X/I+NbB2fIP2+tdjvbWsrN0VErBR+QXIlKb7/5aLx+AGEny74m1epPx/e3ceH+O9/n/8Pdl3kSALWSwh0eJrKSdUI61vLW0PXY7TFqXUaYuiWofTVpfTUqqtbn7B6eJ3+qDbaWnr8O03VWIpogjtoUFrL9UWlSAkmc/3j1uGkUUyYkbi9Xw8PDJz3/fccw2XSXLN576uy0HKmeLGsqnSssnW7Ztecm7kjtot/TFrRU5JE/2S1UW5i63+VEUnrQ/I7v5Q8g9x/XmadbcGHQTWtfp1Xsy5ahtvH2sKZnCkpyOpPm3utL7uyLTaAgTUsXo2usLmpeI+M60PaH75XlpUTj+7U/nWFNqSlWoDF1i9/lx1OV36BsBZhyHW//P/6u/8cycqhXc31GwBYdKNZ4oQy1+0mrRX1qYPrMa/xaesqSxDz/zg+9NGKf+Xih974rB1KZYk1Wteen94gtWny154dshBiZIea1VdsXa+hFTp3kVWI+PmvawVT5WZmoULq58iBdWT7EVW35p291hFstCoyj3eP9R6TFwVCp02m3TjmdVGm94v+zLishQXWpNAJanzQ1Jwvco/J9wjsqk1KMReZP3yUt4E2XPl/Sxt/tC63fmhso/xC5K6jJLGfCeNypFa9Ky2kHERSvqsHdtnfe38kHun78LzbDap1wvWcCV7kTXUYOlkq9de8Wlrguyf51bPZTbNe0h/3Sld//jFnwuXt/otnItaTa+/uEsng+tbA6tsXtbQjY1znfeXFNX2rLZ+ph24oOIPFwHUbJFNpfG7pT5veDqSGonCGmq+VndYK32KTkr/U8neUmtnW1NFTbHU+k6rB1bdhLMrzX5cWvHjS1ar1Ykr+xNim63sAQb24rNDB6rSY608Npv1ifXd71vNYVE9vLysT4a9/aXeL1pNd338L/3zNmwvXX27JCNlPlm5x2x817oMMKielFoLGjTXVr2mWPn041JrheGFrPuH9Qt4o44XbuTsH2K9f+HyUL/F2aE2yTefvcwbVxYvL6lvhrUyreikNZzGXiS16ifdMad6PwirjRPgUbY2d5297UJ/tVIad7VaWEhn+q1ttW6fypfm9TvTH7KOdM98imrAlcBm43uKiyisoeY7d5DB9wuty292r5YKjpU+1hgpa5rV9FuyJjr2zTj7iV/JpMQLDUMoGVxQ1mq1Eo4+a+esPPp9r7VCztufPliXux6TpL/tlToOc+83mOsnSl6+VgFm+TSrGFue0yesfJektL9WbsosPCOiiTVVUJL+5zHrl5bynD4hrXvLut155KWPDdXv1pnSDU9ag05c6dWG2sHb1+rzFZ9q3W83yMoNGrTDVVffbg0A8PKtvuneXcdKTdKtAvBHg62rNub1k3avOjv905WeagBwBeE7O2qHBilWw+DVb1g9bUr62tQ900g6urUUfbXVjH7NmTHs3f4mpY13Lpo0+29rKuOOJVZD+PJ6QTj6qyWXH1NZK9Z+PXMZaEQTftmqCdyxSu18EY2lLqOlFS9aU+W2/a9V/K1XxgrHtTOl/INWkbb9YLeHiiq6doy0+X3pyC5p+QvlDxrYNM8aphKeYK14Qs0T2/bi+hCh9vALkgYttAYX1U9mJQAuTnA9K5/sRZVvT3EhXt7WhwAzr7Xal7zeTjp17ExRbYHUiKIaAFwIK9ZQe9zwpPWLavOe1vRGSTqyU9r6mbT0Oem9O88W1XpOsQYfnP8DblxHqwH8iV+lAznlP1dFgwtKRJesWPvWKtJJ50wErYbLQFF7Xf+E9Mc3rFzcl239sLsm42weSdLJI9KqV6zb6U94pgiIqvENtPouSdLqGWffR85lt0urz7xP/WE4BXigNvD2sT4ApKiG6hB3jdVntzqF1JfueMvqt+Yoqs2nqAYAlURhDbWHj7+10ufuD6SxW6RxP1ojwW98zuqj1uAqKTBC6jvTWt1WFm9fa4S9ZK1aK09lCmv1W0jeftYPKEd3WdsudiIorgw2m9RuoDR8tdSk25n+gROk/3+LtdpJslZWFvxu5XWrOzwZLaqieQ+pRW9rtcG/Hyk9yGDb/1hTjgPqSG0HeCZGAMCVJ/Faa7p0o47SgE+kRi5OHAWAKxCXgqL2Co60ihJNulXtcc26W73adnwppZUxfvxU3tlpbxX1WPP2tT6hPrDJWrUW0eScFWsU1lAJ4XHWZRjfvCX975PS7pXS/+ts5eXaWdYx3Z9iVVNN0/N56YevpF0rpO8+di6Mrj4zian9vWUPRgEA4FJpP8j6AwCoElasAecraQa7L9u63O58v26zvgY3kIIiKj5XyeWgB84MMCjpscaKNVSWzSZdc5/04CopoYtUeFz68mmpqMBqiJ10o6cjRFXVTZS6PmLd/uJxq1gvSfs3WM2ivXykTvd7LDwAAAAAlUdhDThfeJzVYNjYpR+Xld5fmctAS5zbZ+1UvpT3k3WfHmuoqojGVsPinlOsiWA2L6n7M/Tsqak6j7KGq+QflJZNsbaVrFa7+g4pLNZzsQEAAACoNAprQFlKVq3t+LL0vl++t75WNBG0RExJYW2z9NuZ1WpB9aTAuhcfI648Xl5Wf8BRG6UHVknxnTwdEVzlGyD1nmbdXpNhTX/9zwLrfuoIj4UFAAAAoGoorAFlaXaD9XXHktLNxX85cyloZVasRV0lySblHZD2rLa20V8NFyssVopq6ekocLGS/ltKvlkyxdL7d1tfG193tiAPAAAA4LJHYQ0oS3xnyTfIKoj9/B/nfY4Va5UorPmHWkMLJOm7T6yvkVwGCuCMns9LPoGSvdC6n/qQZ+MBAAAAUCUU1oCy+AZIiV2t2+deDlp4Ujq627pdrxKFNens6pN92Wcex4o1AGeEx0vXPWrdrp989jJ0AAAAADUChTWgPGX1WftthzXUICBcCmlQufNEt3K+z0RQAOe69mGpzwzpznlWHz0AAAAANYaPpwMALlslfdb2rJFO5VmXdZ47EbSy0xij2zjfZ8UagHN5eUttB3g6CgAAAAAu4KNxoDyRTa3+aPZCaedya9u5hbXKOnfFmpePVDex2kIEAAAAAACeQ2ENqMj5l4M6BhckV/4coVFSSJR1u26i5O1bbeEBAAAAAADPobAGVOTcwpox0q/brPuVHVxQomTVGv3VAAAAAACoNSisARVJvFby9pOO7pEObbWGF0hVuxRUkuL/YH2N/a9qDQ8AAAAAAHgOwwuAivgFSwldpB+XStmzJXuR5Bss1WlUtfOkjpQaXCU1Sbs0cQIAAAAAALdjxRpwISWXg256z/pav3nlJ4KW8A2UkntbhToAAAAAAFArUFgDLqSksFZUYH2tyuACAAAAAABQa1FYAy6kfgsp7JxLP+s191wsAAAAAADgskFhDbgQm01K6n72PivWAAAAAACAKKwBldPs3MJaFSeCAgAAAACAWompoEBlNE6TgutbQwjCEzwdDQAAAAAAuAxQWAMqIyBMevBryeYtefPfBgAAAAAAUFgDKi+kgacjAAAAAAAAlxF6rAEAAAAAAAAuoLAGAAAAAAAAuIDCGgAAAAAAAOACCmsAAAAAAACACyisAQAAAAAAAC6gsAYAAAAAAAC4gMIaAAAAAAAA4AIKawAAAAAAAIALKKwBAAAAAAAALqCwBgAAAAAAALiAwhoAAAAAAADgAgprAAAAAAAAgAsorAEAAAAAAAAuoLAGAAAAAAAAuMDH0wFcDowxkqRjx455OJLqUVhYqBMnTujYsWPy9fX1dDio5cg3uAu5Bnci3+Au5BrciXyDu5BrcJdLlWsl9aGSelFFKKxJysvLkyTFxcV5OBIAAAAAAABcDvLy8lSnTp0Kj7GZypTfajm73a6ffvpJoaGhstlsng7noh07dkxxcXHau3evwsLCPB0OajnyDe5CrsGdyDe4C7kGdyLf4C7kGtzlUuWaMUZ5eXmKjY2Vl1fFXdRYsSbJy8tLjRo18nQY1S4sLIw3MbgN+QZ3IdfgTuQb3IVcgzuRb3AXcg3ucily7UIr1UowvAAAAAAAAABwAYU1AAAAAAAAwAUU1mohf39/PfXUU/L39/d0KLgCkG9wF3IN7kS+wV3INbgT+QZ3IdfgLpdDrjG8AAAAAAAAAHABK9YAAAAAAAAAF1BYAwAAAAAAAFxAYQ0AAAAAAABwAYU1AAAAAAAAwAUU1mqhGTNmKDExUQEBAerUqZOys7M9HRJquOeff17XXHONQkND1aBBA/Xt21e5ublOxxQUFGjEiBGKjIxUSEiIbr/9dv38888eihi1xZQpU2Sz2TRmzBjHNnIN1Wn//v0aMGCAIiMjFRgYqFatWumbb75x7DfG6Mknn1RMTIwCAwPVvXt3bd++3YMRoyYqLi7WxIkT1bhxYwUGBqpp06Z69tlnde4MMXINrlq+fLluueUWxcbGymazacGCBU77K5Nbhw8fVv/+/RUWFqbw8HANHTpU+fn5bnwVqAkqyrXCwkKNHz9erVq1UnBwsGJjY3XPPffop59+cjoHuYbKutB727keeOAB2Ww2vfLKK07b3ZVvFNZqmQ8++EBjx47VU089pQ0bNqhNmzbq0aOHDh065OnQUINlZWVpxIgRWrNmjTIzM1VYWKgbb7xRx48fdxzz8MMP6/PPP9dHH32krKws/fTTT7rttts8GDVqunXr1mnWrFlq3bq103ZyDdXlyJEj6tKli3x9fbV48WJt2bJFL730kurWres45oUXXtBrr72mmTNnau3atQoODlaPHj1UUFDgwchR00ydOlUZGRl64403tHXrVk2dOlUvvPCCXn/9dccx5Bpcdfz4cbVp00YzZswoc39lcqt///76z3/+o8zMTC1cuFDLly/XX/7yF3e9BNQQFeXaiRMntGHDBk2cOFEbNmzQJ598otzcXP3xj390Oo5cQ2Vd6L2txPz587VmzRrFxsaW2ue2fDOoVTp27GhGjBjhuF9cXGxiY2PN888/78GoUNscOnTISDJZWVnGGGOOHj1qfH19zUcffeQ4ZuvWrUaSWb16tafCRA2Wl5dnkpKSTGZmpklLSzOjR482xpBrqF7jx4831157bbn77Xa7iY6ONtOmTXNsO3r0qPH39zfvvfeeO0JELXHTTTeZIUOGOG277bbbTP/+/Y0x5BqqjyQzf/58x/3K5NaWLVuMJLNu3TrHMYsXLzY2m83s37/fbbGjZjk/18qSnZ1tJJndu3cbY8g1uK68fNu3b59p2LCh+e6770xCQoKZPn26Y587840Va7XI6dOntX79enXv3t2xzcvLS927d9fq1as9GBlqm99//12SFBERIUlav369CgsLnXIvOTlZ8fHx5B5cMmLECN10001OOSWRa6hen332mTp06KA//elPatCggdq2bat//OMfjv07d+7UwYMHnfKtTp066tSpE/mGKuncubOWLFmibdu2SZI2bdqklStXqlevXpLINVw6lcmt1atXKzw8XB06dHAc0717d3l5eWnt2rVujxm1x++//y6bzabw8HBJ5Bqql91u18CBAzVu3DhdddVVpfa7M998qvVs8Khff/1VxcXFioqKctoeFRWl77//3kNRobax2+0aM2aMunTpoquvvlqSdPDgQfn5+Tm+aZaIiorSwYMHPRAlarL3339fGzZs0Lp160rtI9dQnX788UdlZGRo7Nixeuyxx7Ru3TqNGjVKfn5+GjRokCOnyvq+Sr6hKiZMmKBjx44pOTlZ3t7eKi4u1qRJk9S/f39JItdwyVQmtw4ePKgGDRo47ffx8VFERAT5B5cVFBRo/PjxuuuuuxQWFiaJXEP1mjp1qnx8fDRq1Kgy97sz3yisAaiSESNG6LvvvtPKlSs9HQpqob1792r06NHKzMxUQECAp8NBLWe329WhQwdNnjxZktS2bVt99913mjlzpgYNGuTh6FCbfPjhh5o7d67mzZunq666Sjk5ORozZoxiY2PJNQC1TmFhofr16ydjjDIyMjwdDmqh9evX69VXX9WGDRtks9k8HQ7DC2qTevXqydvbu9R0vJ9//lnR0dEeigq1yciRI7Vw4UItXbpUjRo1cmyPjo7W6dOndfToUafjyT1U1fr163Xo0CG1a9dOPj4+8vHxUVZWll577TX5+PgoKiqKXEO1iYmJUcuWLZ22paSkaM+ePZLkyCm+r+JijRs3ThMmTNCdd96pVq1aaeDAgXr44Yf1/PPPSyLXcOlUJreio6NLDTorKirS4cOHyT9UWUlRbffu3crMzHSsVpPINVSfFStW6NChQ4qPj3f8zrB792498sgjSkxMlOTefKOwVov4+fmpffv2WrJkiWOb3W7XkiVLlJqa6sHIUNMZYzRy5EjNnz9fX331lRo3buy0v3379vL19XXKvdzcXO3Zs4fcQ5XccMMN+vbbb5WTk+P406FDB/Xv399xm1xDdenSpYtyc3Odtm3btk0JCQmSpMaNGys6Otop344dO6a1a9eSb6iSEydOyMvL+cdub29v2e12SeQaLp3K5FZqaqqOHj2q9evXO4756quvZLfb1alTJ7fHjJqrpKi2fft2ffnll4qMjHTaT66hugwcOFCbN292+p0hNjZW48aN0xdffCHJvfnGpaC1zNixYzVo0CB16NBBHTt21CuvvKLjx4/r3nvv9XRoqMFGjBihefPm6dNPP1VoaKjjmvQ6deooMDBQderU0dChQzV27FhFREQoLCxMDz30kFJTU/WHP/zBw9GjJgkNDXX07isRHBysyMhIx3ZyDdXl4YcfVufOnTV58mT169dP2dnZmj17tmbPni1JstlsGjNmjJ577jklJSWpcePGmjhxomJjY9W3b1/PBo8a5ZZbbtGkSZMUHx+vq666Shs3btTLL7+sIUOGSCLXcHHy8/O1Y8cOx/2dO3cqJydHERERio+Pv2BupaSkqGfPnho2bJhmzpypwsJCjRw5UnfeeadiY2M99KpwOaoo12JiYnTHHXdow4YNWrhwoYqLix2/M0RERMjPz49cQ5Vc6L3t/MKtr6+voqOj1aJFC0lufm+r1hmjuCy8/vrrJj4+3vj5+ZmOHTuaNWvWeDok1HCSyvzzzjvvOI45efKkGT58uKlbt64JCgoyt956qzlw4IDngkatkZaWZkaPHu24T66hOn3++efm6quvNv7+/iY5OdnMnj3bab/dbjcTJ040UVFRxt/f39xwww0mNzfXQ9Gipjp27JgZPXq0iY+PNwEBAaZJkybm8ccfN6dOnXIcQ67BVUuXLi3z57RBgwYZYyqXW7/99pu56667TEhIiAkLCzP33nuvycvL88CrweWsolzbuXNnub8zLF261HEOcg2VdaH3tvMlJCSY6dOnO21zV77ZjDGmekt1AAAAAAAAQO1HjzUAAAAAAADABRTWAAAAAAAAABdQWAMAAAAAAABcQGENAAAAAAAAcAGFNQAAAAAAAMAFFNYAAAAAAAAAF1BYAwAAAAAAAFxAYQ0AAAAAAABwAYU1AACAShg8eLD69u3ruN+tWzeNGTPmos5ZHee4VKojtl27dslmsyknJ6daYnKXZcuWyWaz6ejRo54OBQAAXOYorAEAgBpr8ODBstlsstls8vPzU7NmzfT3v/9dRUVFl/y5P/nkEz377LOVOra8Qk1VzuGqmJgYTZkyxWnbhAkTZLPZtGzZMqft3bp108CBA90W26WQmJioV155xdNhAACAKwSFNQAAUKP17NlTBw4c0Pbt2/XII4/o6aef1rRp08o89vTp09X2vBEREQoNDfX4OS6kW7dupQpoS5cuVVxcnNP2goICrVmzRtdff73bYgMAAKjpKKwBAIAazd/fX9HR0UpISNCDDz6o7t2767PPPpN09vLNSZMmKTY2Vi1atJAk7d27V/369VN4eLgiIiLUp08f7dq1y3HO4uJijR07VuHh4YqMjNRf//pXGWOcnvf8SyVPnTql8ePHKy4uTv7+/mrWrJneeust7dq1S+np6ZKkunXrymazafDgwWWe48iRI7rnnntUt25dBQUFqVevXtq+fbtj/5w5cxQeHq4vvvhCKSkpCgkJcRQWy5Oenq5Vq1Y5VvHl5eVp48aNGj9+vFNhbfXq1Tp16pQj1vNjS0xM1OTJkzVkyBCFhoYqPj5es2fPdnqu7OxstW3bVgEBAerQoYM2btxYKp6srCx17NhR/v7+iomJ0YQJExyxLVy4UOHh4SouLpYk5eTkyGazacKECY7H33fffRowYEC5r/d8NptNb775pm699VYFBQUpKSnJkR8lFi1apObNmyswMFDp6elOuVBi5cqV6tq1qwIDAxUXF6dRo0bp+PHjkqR//vOfCgkJcfq3Gj58uJKTk3XixIlKxwoAAGoeCmsAAKBWCQwMdFqZtmTJEuXm5iozM1MLFy5UYWGhevToodDQUK1YsUKrVq1yFKhKHvfSSy9pzpw5evvtt7Vy5UodPnxY8+fPr/B577nnHr333nt67bXXtHXrVs2aNUshISGKi4vTxx9/LEnKzc3VgQMH9Oqrr5Z5jsGDB+ubb77RZ599ptWrV8sYo969e6uwsNBxzIkTJ/Tiiy/q3Xff1fLly7Vnzx49+uij5caVnp6u/Px8rVu3TpK0YsUKNW/eXLfffrvWrl2rgoICSdYqtsTERCUmJpZ7rpdeeslRMBs+fLgefPBB5ebmSpLy8/N18803q2XLllq/fr2efvrpUnHt379fvXv31jXXXKNNmzYpIyNDb731lp577jlJUteuXR2FP8kqwtWrV8+pAJiVlaVu3bqVG2NZnnnmGfXr10+bN29W79691b9/fx0+fFiSVWS97bbbdMsttygnJ0f33XefUyFPkn744Qf17NlTt99+uzZv3qwPPvhAK1eu1MiRIyVZ//Yl5y0qKtK///1vvfnmm5o7d66CgoKqFCsAAKhhDAAAQA01aNAg06dPH2OMMXa73WRmZhp/f3/z6KOPOvZHRUWZU6dOOR7z7rvvmhYtWhi73e7YdurUKRMYGGi++OILY4wxMTEx5oUXXnDsLywsNI0aNXI8lzHGpKWlmdGjRxtjjMnNzTWSTGZmZplxLl261EgyR44ccdp+7jm2bdtmJJlVq1Y59v/6668mMDDQfPjhh8YYY9555x0jyezYscNxzIwZM0xUVFSFf08NGzY0kydPNsYYM27cODN8+HBjjDHNmzc3X331lTHGmK5du5p77723zNiMMSYhIcEMGDDAcd9ut5sGDRqYjIwMY4wxs2bNMpGRkebkyZOOYzIyMowks3HjRmOMMY899lipv/sZM2aYkJAQU1xcbIwxpl27dmbatGnGGGP69u1rJk2aZPz8/ExeXp7Zt2+fkWS2bdtW7mtNSEgw06dPd9yXZJ544gnH/fz8fCPJLF682BhjzN/+9jfTsmVLp3OMHz/e6d9r6NCh5i9/+YvTMStWrDBeXl6O13v48GHTqFEj8+CDD5qoqCgzadKkcmMEAAC1ByvWAABAjbZw4UKFhIQoICBAvXr10p///Gc9/fTTjv2tWrWSn5+f4/6mTZu0Y8cOhYaGKiQkRCEhIYqIiFBBQYF++OEH/f777zpw4IA6derkeIyPj486dOhQbgw5OTny9vZWWlqay69j69at8vHxcXreyMhItWjRQlu3bnVsCwoKUtOmTR33Y2JidOjQoQrPfW6ftWXLljlWfKWlpWnZsmU6efKk1q5d67gMtDytW7d23LbZbIqOjnY899atW9W6dWsFBAQ4jklNTS31GlNTU2Wz2RzbunTpovz8fO3bt88pJmOMVqxYodtuu00pKSlauXKlsrKyFBsbq6SkpArjrCju4OBghYWFOcV97t95WXFv2rRJc+bMceRLSEiIevToIbvdrp07d0qyLvN96623lJGRoaZNm5Za9QYAAGonH08HAAAAcDHS09OVkZEhPz8/xcbGysfH+ceb4OBgp/v5+flq37695s6dW+pc9evXdymGwMBAlx7nCl9fX6f7NputVP+386Wnp2v06NH67bfftHHjRkcBMC0tTbNmzdJ1112n06dPOwYXVOW57Xa7C6+ifN26ddPbb7+tTZs2ydfXV8nJyY7C4JEjR1wqXl5s3Pn5+br//vs1atSoUvvi4+Mdt5cvXy5vb28dOHBAx48fZ/gDAABXAFasAQCAGi04OFjNmjVTfHx8qaJaWdq1a6ft27erQYMGatasmdOfOnXqqE6dOoqJidHatWsdjykqKtL69evLPWerVq1kt9uVlZVV5v6SFXMlTfnLkpKSoqKiIqfn/e2335Sbm6uWLVte8HVVJD09XcePH9fLL7+spKQkNWjQQJJ03XXXKTs7W4sXL1ZSUpIaNmzo8nOkpKRo8+bNjp5tkrRmzZpSx5T0jiuxatUqhYaGqlGjRpLO9lmbPn26o4hWUlg7d7VddUlJSVF2drbTtvPjbteunbZs2VIqX5o1a+b4t/366681depUff755woJCXH0XwMAALUbhTUAAHBF6d+/v+rVq6c+ffpoxYoV2rlzp5YtW6ZRo0Y5LkccPXq0pkyZogULFuj777/X8OHDdfTo0XLPmZiYqEGDBmnIkCFasGCB45wffvihJCkhIUE2m00LFy7UL7/8ovz8/FLnSEpKUp8+fTRs2DCtXLlSmzZt0oABA9SwYUP16dPnol5zkyZNFB8fr9dff91pxVdcXJxiY2M1e/bsC14GeiF33323bDabhg0bpi1btmjRokV68cUXnY4ZPny49u7dq4ceekjff/+9Pv30Uz311FMaO3asvLysH0vr1q2r1q1ba+7cuY4i2nXXXacNGzZo27ZtF3W5bVkeeOABbd++XePGjVNubq7mzZunOXPmOB0zfvx4ff311xo5cqRycnK0fft2ffrpp47iWV5engYOHKhRo0apV69emjt3rj744AP961//qtZYAQDA5YfCGgAAuKIEBQVp+fLlio+Pd/TvGjp0qAoKChQWFiZJeuSRRzRw4EANGjRIqampCg0N1a233lrheTMyMnTHHXdo+PDhSk5O1rBhw3T8+HFJUsOGDfXMM89owoQJioqKKnc10zvvvKP27dvr5ptvVmpqqowxWrRoUalLGV2Rnp6uvLy8Uiu+0tLSlJeXd9GFtZCQEH3++ef69ttv1bZtWz3++OOaOnWq0zENGzbUokWLlJ2drTZt2uiBBx7Q0KFD9cQTT5SKqbi42BFrRESEWrZsqejoaLVo0eKi4jxffHy8Pv74Yy1YsEBt2rTRzJkzNXnyZKdjWrduraysLG3btk1du3ZV27Zt9eSTTyo2NlaSVYgNDg52PK5Vq1aaPHmy7r//fu3fv79a4wUAAJcXm7lQUw4AAAAAAAAApbBiDQAAAAAAAHABhTUAAAAAAADABRTWAAAAAAAAABdQWAMAAAAAAABcQGENAAAAAAAAcAGFNQAAAAAAAMAFFNYAAAAAAAAAF1BYAwAAAAAAAFxAYQ0AAAAAAABwAYU1AAAAAAAAwAUU1gAAAAAAAAAX/B/GGOP5fQpnKgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import libraries\n",
    "import cv2\n",
    "import numpy as np\n",
    "import mediapipe as mp\n",
    "from scipy.signal import butter, filtfilt, detrend\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from google.colab import files\n",
    "\n",
    "# Upload ground truth (optional)\n",
    "uploaded = files.upload()\n",
    "gt_path = next(iter(uploaded))\n",
    "\n",
    "# Paths\n",
    "video_path = '/content/drive/MyDrive/3video.avi'\n",
    "model_path = '/content/drive/MyDrive/1-D_Resnet_val_3.66_10k.pth'  # Your model\n",
    "\n",
    "# Face Mesh setup\n",
    "mp_face_mesh = mp.solutions.face_mesh\n",
    "face_mesh = mp_face_mesh.FaceMesh(\n",
    "    static_image_mode=False,\n",
    "    max_num_faces=1,\n",
    "    refine_landmarks=True,\n",
    "    min_detection_confidence=0.5,\n",
    "    min_tracking_confidence=0.5\n",
    ")\n",
    "\n",
    "# Functions\n",
    "def bandpass_filter(signal, fs, low=0.7, high=3.0, order=4):\n",
    "    nyq = 0.5 * fs\n",
    "    b, a = butter(order, [low/nyq, high/nyq], btype=\"band\")\n",
    "    return filtfilt(b, a, signal)\n",
    "\n",
    "def normalize_signal(signal):\n",
    "    return (signal - np.min(signal)) / (np.max(signal) - np.min(signal))\n",
    "\n",
    "def get_face_mask(landmarks, img_shape):\n",
    "    face_idx = list(range(468))\n",
    "    h, w = img_shape\n",
    "    points = np.array([(int(landmarks[i].x * w), int(landmarks[i].y * h)) for i in face_idx])\n",
    "    hull = cv2.convexHull(points)\n",
    "    mask = np.zeros((h, w), dtype=np.uint8)\n",
    "    cv2.fillConvexPoly(mask, hull, 255)\n",
    "    return mask\n",
    "\n",
    "# Define Residual Block 1D\n",
    "class ResidualBlock1D(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, stride=1, downsample=None):\n",
    "        super(ResidualBlock1D, self).__init__()\n",
    "        self.conv1 = nn.Conv1d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)\n",
    "        self.bn1 = nn.BatchNorm1d(out_channels)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.conv2 = nn.Conv1d(out_channels, out_channels, kernel_size=3, padding=1)\n",
    "        self.bn2 = nn.BatchNorm1d(out_channels)\n",
    "        self.downsample = downsample\n",
    "\n",
    "    def forward(self, x):\n",
    "        identity = x\n",
    "        out = self.relu(self.bn1(self.conv1(x)))\n",
    "        out = self.bn2(self.conv2(out))\n",
    "        if self.downsample:\n",
    "            identity = self.downsample(x)\n",
    "        out += identity\n",
    "        return self.relu(out)\n",
    "\n",
    "# Define full ResNet1D\n",
    "class ResNet1D(nn.Module):\n",
    "    def __init__(self, in_channels, num_classes=2):\n",
    "        super(ResNet1D, self).__init__()\n",
    "        self.layer0 = nn.Sequential(\n",
    "            nn.Conv1d(in_channels, 64, kernel_size=7, stride=2, padding=3),\n",
    "            nn.BatchNorm1d(64),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool1d(kernel_size=3, stride=2, padding=1)\n",
    "        )\n",
    "        self.layer1 = self._make_layer(64, 64, blocks=2)\n",
    "        self.layer2 = self._make_layer(64, 128, blocks=2, stride=2)\n",
    "        self.layer3 = self._make_layer(128, 256, blocks=2, stride=2)\n",
    "        self.layer4 = self._make_layer(256, 512, blocks=2, stride=2)\n",
    "        self.global_pool = nn.AdaptiveAvgPool1d(1)\n",
    "        self.fc = nn.Linear(512, num_classes)\n",
    "\n",
    "    def _make_layer(self, in_channels, out_channels, blocks, stride=1):\n",
    "        downsample = None\n",
    "        if stride != 1 or in_channels != out_channels:\n",
    "            downsample = nn.Sequential(\n",
    "                nn.Conv1d(in_channels, out_channels, kernel_size=1, stride=stride),\n",
    "                nn.BatchNorm1d(out_channels)\n",
    "            )\n",
    "        layers = [ResidualBlock1D(in_channels, out_channels, stride, downsample)]\n",
    "        for _ in range(1, blocks):\n",
    "            layers.append(ResidualBlock1D(out_channels, out_channels))\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.layer0(x)\n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "        x = self.global_pool(x)\n",
    "        x = torch.flatten(x, 1)\n",
    "        return self.fc(x)\n",
    "\n",
    "# Step 1: Extract iPPG from video\n",
    "cap = cv2.VideoCapture(video_path)\n",
    "fps = cap.get(cv2.CAP_PROP_FPS) or 30.0\n",
    "print(f\"Video FPS: {fps}\")\n",
    "\n",
    "signals = []\n",
    "timestamps = []\n",
    "\n",
    "while True:\n",
    "    ret, frame = cap.read()\n",
    "    if not ret:\n",
    "        break\n",
    "    ts = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0\n",
    "    img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "    res = face_mesh.process(img_rgb)\n",
    "    if not res.multi_face_landmarks:\n",
    "        continue\n",
    "    landmarks = res.multi_face_landmarks[0].landmark\n",
    "    mask = get_face_mask(landmarks, frame.shape[:2])\n",
    "\n",
    "    green = frame[:, :, 1]\n",
    "    skin_pixels = green[mask > 0]\n",
    "\n",
    "    if skin_pixels.size == 0:\n",
    "        continue\n",
    "\n",
    "    green_mean = np.mean(skin_pixels)\n",
    "    signals.append(green_mean)\n",
    "    timestamps.append(ts)\n",
    "\n",
    "cap.release()\n",
    "\n",
    "signals = np.array(signals)\n",
    "timestamps = np.array(timestamps)\n",
    "print(f\"Extracted {len(signals)} frames.\")\n",
    "\n",
    "# Preprocessing\n",
    "signals_detrended = detrend(signals)\n",
    "signals_filtered = bandpass_filter(signals_detrended, fps)\n",
    "ppg_signal = normalize_signal(signals_filtered)\n",
    "\n",
    "# Step 2: Load ResNet1D model\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = ResNet1D(in_channels=1, num_classes=2).to(device)\n",
    "model.load_state_dict(torch.load(model_path, map_location=device))\n",
    "model.eval()\n",
    "\n",
    "# Step 3: Predict BP (using sliding window)\n",
    "window_size = 437\n",
    "step_size = 10\n",
    "\n",
    "predictions = []\n",
    "\n",
    "for start in range(0, len(ppg_signal) - window_size, step_size):\n",
    "    segment = ppg_signal[start:start + window_size]\n",
    "    segment = torch.tensor(segment, dtype=torch.float32).unsqueeze(0).unsqueeze(0).to(device)  # shape (1, 1, 437)\n",
    "    with torch.no_grad():\n",
    "        pred = model(segment)\n",
    "    predictions.append(pred.cpu().numpy().flatten())  # shape (2,)\n",
    "\n",
    "predictions = np.array(predictions)\n",
    "print(f\"Computed {len(predictions)} BP windows.\")\n",
    "\n",
    "# ---- New: print each window's systolic & diastolic ----\n",
    "for i, (sys, dia) in enumerate(predictions):\n",
    "    print(f\"Window {i:03d}: Systolic = {sys:.2f}, Diastolic = {dia:.2f}\")\n",
    "\n",
    "# ---- And print overall average BP ----\n",
    "mean_sys = predictions[:,0].mean()\n",
    "mean_dia = predictions[:,1].mean()\n",
    "print(f\"\\nAverage Predicted → Systolic: {mean_sys:.2f}, Diastolic: {mean_dia:.2f}\")\n",
    "\n",
    "# Step 4: Plot BP\n",
    "plt.figure(figsize=(15, 5))\n",
    "plt.plot(predictions[:, 0], label='Predicted Systolic BP')\n",
    "plt.plot(predictions[:, 1], label='Predicted Diastolic BP')\n",
    "plt.legend()\n",
    "plt.title('Predicted BP Signal from iPPG (ResNet1D)')\n",
    "plt.xlabel('Prediction Window Index')\n",
    "plt.ylabel('BP Value')\n",
    "plt.grid()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "executionInfo": {
     "elapsed": 21973,
     "status": "ok",
     "timestamp": 1748324270788,
     "user": {
      "displayName": "Yusuf Khan",
      "userId": "12411237408315334872"
     },
     "user_tz": -330
    },
    "id": "gKPdMxa9OqZ0",
    "outputId": "a88d769f-102a-4e95-83a9-438bc87ed8d6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: gradio in /usr/local/lib/python3.11/dist-packages (5.31.0)\n",
      "Requirement already satisfied: torch in /usr/local/lib/python3.11/dist-packages (2.6.0+cu124)\n",
      "Requirement already satisfied: torchvision in /usr/local/lib/python3.11/dist-packages (0.21.0+cu124)\n",
      "Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (1.15.3)\n",
      "Requirement already satisfied: aiofiles<25.0,>=22.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (24.1.0)\n",
      "Requirement already satisfied: anyio<5.0,>=3.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (4.9.0)\n",
      "Requirement already satisfied: fastapi<1.0,>=0.115.2 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.115.12)\n",
      "Requirement already satisfied: ffmpy in /usr/local/lib/python3.11/dist-packages (from gradio) (0.5.0)\n",
      "Requirement already satisfied: gradio-client==1.10.1 in /usr/local/lib/python3.11/dist-packages (from gradio) (1.10.1)\n",
      "Requirement already satisfied: groovy~=0.1 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.1.2)\n",
      "Requirement already satisfied: httpx>=0.24.1 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.28.1)\n",
      "Requirement already satisfied: huggingface-hub>=0.28.1 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.31.2)\n",
      "Requirement already satisfied: jinja2<4.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (3.1.6)\n",
      "Requirement already satisfied: markupsafe<4.0,>=2.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (3.0.2)\n",
      "Requirement already satisfied: numpy<3.0,>=1.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (2.0.2)\n",
      "Requirement already satisfied: orjson~=3.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (3.10.18)\n",
      "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from gradio) (24.2)\n",
      "Requirement already satisfied: pandas<3.0,>=1.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (2.2.2)\n",
      "Requirement already satisfied: pillow<12.0,>=8.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (11.2.1)\n",
      "Requirement already satisfied: pydantic<2.12,>=2.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (2.11.4)\n",
      "Requirement already satisfied: pydub in /usr/local/lib/python3.11/dist-packages (from gradio) (0.25.1)\n",
      "Requirement already satisfied: python-multipart>=0.0.18 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.0.20)\n",
      "Requirement already satisfied: pyyaml<7.0,>=5.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (6.0.2)\n",
      "Requirement already satisfied: ruff>=0.9.3 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.11.11)\n",
      "Requirement already satisfied: safehttpx<0.2.0,>=0.1.6 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.1.6)\n",
      "Requirement already satisfied: semantic-version~=2.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (2.10.0)\n",
      "Requirement already satisfied: starlette<1.0,>=0.40.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.46.2)\n",
      "Requirement already satisfied: tomlkit<0.14.0,>=0.12.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.13.2)\n",
      "Requirement already satisfied: typer<1.0,>=0.12 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.15.3)\n",
      "Requirement already satisfied: typing-extensions~=4.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (4.13.2)\n",
      "Requirement already satisfied: uvicorn>=0.14.0 in /usr/local/lib/python3.11/dist-packages (from gradio) (0.34.2)\n",
      "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from gradio-client==1.10.1->gradio) (2025.3.2)\n",
      "Requirement already satisfied: websockets<16.0,>=10.0 in /usr/local/lib/python3.11/dist-packages (from gradio-client==1.10.1->gradio) (15.0.1)\n",
      "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch) (3.18.0)\n",
      "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch) (3.4.2)\n",
      "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n",
      "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n",
      "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n",
      "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /usr/local/lib/python3.11/dist-packages (from torch) (9.1.0.70)\n",
      "Requirement already satisfied: nvidia-cublas-cu12==12.4.5.8 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.5.8)\n",
      "Requirement already satisfied: nvidia-cufft-cu12==11.2.1.3 in /usr/local/lib/python3.11/dist-packages (from torch) (11.2.1.3)\n",
      "Requirement already satisfied: nvidia-curand-cu12==10.3.5.147 in /usr/local/lib/python3.11/dist-packages (from torch) (10.3.5.147)\n",
      "Requirement already satisfied: nvidia-cusolver-cu12==11.6.1.9 in /usr/local/lib/python3.11/dist-packages (from torch) (11.6.1.9)\n",
      "Requirement already satisfied: nvidia-cusparse-cu12==12.3.1.170 in /usr/local/lib/python3.11/dist-packages (from torch) (12.3.1.170)\n",
      "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch) (0.6.2)\n",
      "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch) (2.21.5)\n",
      "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n",
      "Requirement already satisfied: nvidia-nvjitlink-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n",
      "Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch) (3.2.0)\n",
      "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch) (1.13.1)\n",
      "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch) (1.3.0)\n",
      "Requirement already satisfied: idna>=2.8 in /usr/local/lib/python3.11/dist-packages (from anyio<5.0,>=3.0->gradio) (3.10)\n",
      "Requirement already satisfied: sniffio>=1.1 in /usr/local/lib/python3.11/dist-packages (from anyio<5.0,>=3.0->gradio) (1.3.1)\n",
      "Requirement already satisfied: certifi in /usr/local/lib/python3.11/dist-packages (from httpx>=0.24.1->gradio) (2025.4.26)\n",
      "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.11/dist-packages (from httpx>=0.24.1->gradio) (1.0.9)\n",
      "Requirement already satisfied: h11>=0.16 in /usr/local/lib/python3.11/dist-packages (from httpcore==1.*->httpx>=0.24.1->gradio) (0.16.0)\n",
      "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from huggingface-hub>=0.28.1->gradio) (2.32.3)\n",
      "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub>=0.28.1->gradio) (4.67.1)\n",
      "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.11/dist-packages (from pandas<3.0,>=1.0->gradio) (2.9.0.post0)\n",
      "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas<3.0,>=1.0->gradio) (2025.2)\n",
      "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas<3.0,>=1.0->gradio) (2025.2)\n",
      "Requirement already satisfied: annotated-types>=0.6.0 in /usr/local/lib/python3.11/dist-packages (from pydantic<2.12,>=2.0->gradio) (0.7.0)\n",
      "Requirement already satisfied: pydantic-core==2.33.2 in /usr/local/lib/python3.11/dist-packages (from pydantic<2.12,>=2.0->gradio) (2.33.2)\n",
      "Requirement already satisfied: typing-inspection>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from pydantic<2.12,>=2.0->gradio) (0.4.0)\n",
      "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.11/dist-packages (from typer<1.0,>=0.12->gradio) (8.2.0)\n",
      "Requirement already satisfied: shellingham>=1.3.0 in /usr/local/lib/python3.11/dist-packages (from typer<1.0,>=0.12->gradio) (1.5.4)\n",
      "Requirement already satisfied: rich>=10.11.0 in /usr/local/lib/python3.11/dist-packages (from typer<1.0,>=0.12->gradio) (13.9.4)\n",
      "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.8.2->pandas<3.0,>=1.0->gradio) (1.17.0)\n",
      "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich>=10.11.0->typer<1.0,>=0.12->gradio) (3.0.0)\n",
      "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich>=10.11.0->typer<1.0,>=0.12->gradio) (2.19.1)\n",
      "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->huggingface-hub>=0.28.1->gradio) (3.4.2)\n",
      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->huggingface-hub>=0.28.1->gradio) (2.4.0)\n",
      "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich>=10.11.0->typer<1.0,>=0.12->gradio) (0.1.2)\n",
      "Colab notebook detected. To show errors in colab notebook, set debug=True in launch()\n",
      "* Running on public URL: https://87c77536c203f5502f.gradio.live\n",
      "\n",
      "This share link expires in 1 week. For free permanent hosting and GPU upgrades, run `gradio deploy` from the terminal in the working directory to deploy to Hugging Face Spaces (https://huggingface.co/spaces)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div><iframe src=\"https://87c77536c203f5502f.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Install dependencies\n",
    "!pip install gradio torch torchvision scipy\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "import mediapipe as mp\n",
    "from scipy.signal import butter, filtfilt, detrend\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import gradio as gr\n",
    "\n",
    "# --- Helper functions ---\n",
    "def bandpass_filter(signal, fs, low=0.7, high=3.0, order=4):\n",
    "    nyq = 0.5 * fs\n",
    "    b, a = butter(order, [low/nyq, high/nyq], btype=\"band\")\n",
    "    return filtfilt(b, a, signal)\n",
    "\n",
    "def normalize_signal(signal):\n",
    "    return (signal - np.min(signal)) / (np.max(signal) - np.min(signal))\n",
    "\n",
    "def get_face_mask(landmarks, img_shape):\n",
    "    idx = list(range(468))\n",
    "    h, w = img_shape\n",
    "    pts = np.array([(int(landmarks[i].x * w), int(landmarks[i].y * h)) for i in idx])\n",
    "    hull = cv2.convexHull(pts)\n",
    "    mask = np.zeros((h, w), dtype=np.uint8)\n",
    "    cv2.fillConvexPoly(mask, hull, 255)\n",
    "    return mask\n",
    "\n",
    "# --- Model Definition ---\n",
    "class ResidualBlock1D(nn.Module):\n",
    "    def __init__(self, in_ch, out_ch, stride=1, downsample=None):\n",
    "        super().__init__()\n",
    "        self.conv1 = nn.Conv1d(in_ch, out_ch, 3, stride, 1)\n",
    "        self.bn1   = nn.BatchNorm1d(out_ch)\n",
    "        self.conv2 = nn.Conv1d(out_ch, out_ch, 3, 1, 1)\n",
    "        self.bn2   = nn.BatchNorm1d(out_ch)\n",
    "        self.relu  = nn.ReLU(inplace=True)\n",
    "        self.downsample = downsample\n",
    "\n",
    "    def forward(self, x):\n",
    "        id = x\n",
    "        out = self.relu(self.bn1(self.conv1(x)))\n",
    "        out = self.bn2(self.conv2(out))\n",
    "        if self.downsample:\n",
    "            id = self.downsample(x)\n",
    "        return self.relu(out + id)\n",
    "\n",
    "class ResNet1D(nn.Module):\n",
    "    def __init__(self, in_ch, num_classes=2):\n",
    "        super().__init__()\n",
    "        self.layer0 = nn.Sequential(\n",
    "            nn.Conv1d(in_ch, 64, 7, 2, 3),\n",
    "            nn.BatchNorm1d(64),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool1d(3, 2, 1)\n",
    "        )\n",
    "        self.layer1 = self._make_layer(64,  64, 2)\n",
    "        self.layer2 = self._make_layer(64, 128, 2, stride=2)\n",
    "        self.layer3 = self._make_layer(128,256, 2, stride=2)\n",
    "        self.layer4 = self._make_layer(256,512, 2, stride=2)\n",
    "        self.global_pool = nn.AdaptiveAvgPool1d(1)\n",
    "        self.fc = nn.Linear(512, num_classes)\n",
    "\n",
    "    def _make_layer(self, in_ch, out_ch, blocks, stride=1):\n",
    "        down = None\n",
    "        if stride != 1 or in_ch != out_ch:\n",
    "            down = nn.Sequential(\n",
    "                nn.Conv1d(in_ch, out_ch, 1, stride),\n",
    "                nn.BatchNorm1d(out_ch)\n",
    "            )\n",
    "        layers = [ResidualBlock1D(in_ch, out_ch, stride, down)]\n",
    "        for _ in range(1, blocks):\n",
    "            layers.append(ResidualBlock1D(out_ch, out_ch))\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.layer0(x)\n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "        x = self.global_pool(x)\n",
    "        x = torch.flatten(x, 1)\n",
    "        return self.fc(x)\n",
    "\n",
    "# --- Inference and Plot ---\n",
    "def analyze_video(video_file):\n",
    "    # Face mesh\n",
    "    fm = mp.solutions.face_mesh.FaceMesh(\n",
    "        static_image_mode=False, max_num_faces=1,\n",
    "        refine_landmarks=True, min_detection_confidence=0.5,\n",
    "        min_tracking_confidence=0.5\n",
    "    )\n",
    "\n",
    "    # Read video\n",
    "    cap = cv2.VideoCapture(video_file.name)\n",
    "    fps = cap.get(cv2.CAP_PROP_FPS) or 30.0\n",
    "    sigs = []\n",
    "    while True:\n",
    "        ret, frame = cap.read()\n",
    "        if not ret: break\n",
    "        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "        res = fm.process(rgb)\n",
    "        if not res.multi_face_landmarks: continue\n",
    "        lm = res.multi_face_landmarks[0].landmark\n",
    "        mask = get_face_mask(lm, frame.shape[:2])\n",
    "        skin = frame[:,:,1][mask>0]\n",
    "        if skin.size: sigs.append(np.mean(skin))\n",
    "    cap.release()\n",
    "\n",
    "    # Fixed bandpass range\n",
    "    data = normalize_signal(bandpass_filter(detrend(np.array(sigs)), fps, low=0.7, high=3.0))\n",
    "\n",
    "    # Load model\n",
    "    dev = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "    mdl = ResNet1D(1,2).to(dev)\n",
    "    mdl.load_state_dict(torch.load(model_path, map_location=dev))\n",
    "    mdl.eval()\n",
    "\n",
    "    # Sliding windows\n",
    "    preds = []\n",
    "    w, st = 437, 10\n",
    "    for i in range(0, len(data)-w, st):\n",
    "        seg = torch.tensor(data[i:i+w], dtype=torch.float32).unsqueeze(0).unsqueeze(0).to(dev)\n",
    "        with torch.no_grad(): out = mdl(seg).cpu().numpy().flatten()\n",
    "        preds.append(out)\n",
    "    preds = np.vstack(preds)\n",
    "    avg_sys, avg_dia = preds[:,0].mean(), preds[:,1].mean()\n",
    "\n",
    "    # Plot\n",
    "    fig, ax = plt.subplots(figsize=(8,3))\n",
    "    ax.plot(preds[:,0], label='Systolic')\n",
    "    ax.plot(preds[:,1], label='Diastolic')\n",
    "    ax.set_title('Predicted BP over Time')\n",
    "    ax.legend()\n",
    "    ax.set_xlabel('Window Index')\n",
    "    ax.set_ylabel('BP')\n",
    "    plt.tight_layout()\n",
    "\n",
    "    return f\"Average Systolic: {avg_sys:.2f}, Diastolic: {avg_dia:.2f}\", fig\n",
    "\n",
    "# --- Gradio Interface ---\n",
    "iface = gr.Interface(\n",
    "    fn=analyze_video,\n",
    "    inputs=gr.File(label=\"Upload a Video File\"),  # File upload for video\n",
    "    outputs=[\n",
    "        gr.Textbox(label='Average Predicted Blood Pressure'),\n",
    "        gr.Plot(label='BP Prediction Time Series')\n",
    "    ],\n",
    "    title='rPPG-based BP Prediction'  # Updated title\n",
    ")\n",
    "\n",
    "# Launch for Colab without opening a browser\n",
    "iface.launch(share=True)\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyOOaTxXJ3SqIZvGxl/mDTwy",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
